diff --git a/AGENTS.md b/AGENTS.md index caeba21..6047a4e 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -14,7 +14,7 @@ Ein Server mit WebUI und MCP verwaltet Linux- und Windows-Clients. Die Clients m Für Geräte und Kunden gilt Kapitel 0.7. Änderungen an Kundengrenzen mit beschränktem und globalem Token prüfen, einschließlich Listen, direkter Geräte-IDs und Widerruf. Die Trennung von Bestand und Historie beruht auf der bestätigten Geräteidentität. Bei einem Kundenwechsel neu enrollen und die bisherige Historie beim ursprünglichen Kunden belassen. -Für Skriptaufträge gilt Kapitel 0.8. Die Bibliothek veröffentlicht Skriptversionen. Gerätezuweisung und Ergebniskontrolle gehören zu „Aufträge“, die interaktive Entscheidung zu „Genehmigungen“. Änderungen an einem dieser Wege am Übergang zum nächsten prüfen. +Für Skriptaufträge gelten Kapitel 0.8 und 0.10. Alle neuen Geräteaktionen einschließlich Neustarts verwenden ein Skript. Beim Prüfen eines Neustarts den alten und neuen Bootbezug, die Kopplung und das Ergebnis eines Folgeauftrags festhalten. Die Bibliothek veröffentlicht Skriptversionen. Gerätezuweisung und Ergebniskontrolle gehören zu „Aufträge“, die interaktive Entscheidung zu „Genehmigungen“. Änderungen an einem dieser Wege am Übergang zum nächsten prüfen. ## Betrieb und Freigabe diff --git a/Rust_RMM_Implementierungsspezifikation.md b/Rust_RMM_Implementierungsspezifikation.md index 8b9a95f..dec448c 100644 --- a/Rust_RMM_Implementierungsspezifikation.md +++ b/Rust_RMM_Implementierungsspezifikation.md @@ -1,6 +1,6 @@ # Rust RMM: Architektur und Implementierungsspezifikation -Version 1.38 · 2026-11-18 · Sprache: Deutsch +Version 1.39 · 2026-11-18 · Sprache: Deutsch **Zweck:** Vollständige, eigenständig nutzbare Grundlage für die Implementierung einer mandantenfähigen Plattform zur Inventarisierung, Überwachung und Fernadministration von Kundengeräten durch eine Coding-KI und ein Entwicklungsteam. @@ -114,6 +114,12 @@ Minuten nach Empfang nutzbar (bisher 100 ms). Details Kapitel 0.3. ## 0 Auftrag und verbindliche Produktanforderungen +### 0.10 Ausführbare Geräteaufträge (Version 1.39) + +Jede neue Aktion aus WebUI oder MCP wird als `run_script` geplant. Das gilt auch für Neustarts. Die Bibliothek stellt je eine Revision für Linux (Root) und Windows (SYSTEM) bereit. Plan, Genehmigung und Ergebnis binden die ausgewählte Revision und das Zielgerät. Der Exitcode des Neustartskripts belegt die Annahme durch das Betriebssystem. Die Abnahme eines Neustarts erfordert zusätzlich einen geänderten Bootbezug, einen neuen authentisierten Kontakt und einen erfolgreichen Folgeauftrag der gleichen Kopplung. + +Ein eingeschriebener Client meldet seine tatsächlich verfügbaren Skriptkontexte. Der reguläre Dienst verwendet sein Dienstkonto. Administratorausführung erfordert einen für diese Geräteidentität konfigurierten und verifizierten Helper sowie eine passende zentrale Berechtigung. Eine frühere Freigabe einzelner Wartungsskripte gilt weiterhin nur für deren festgelegten Umfang. Für regulär eingerichtete Administratorausführung ist kein Wartungsfenster pro Auftrag erforderlich. Passive Heartbeats, Inventar, signierte Selbstupdates und die Wiederaufnahme alter Versuchsergebnisse haben eigene Lebenszyklen. Historische typisierte Pläne bleiben einsehbar und können abgelehnt werden. + ### 0.9 Offizieller Windows-Kanal und ausgeschiedene Geräte (Version 1.38) Für Windows x64 wird `x86_64-pc-windows-gnu` als offizielles Ziel gebaut, signiert und vom HTTPS-Installer standardmäßig gewählt. Das veröffentlichte Agent-/Helperpaar und der stabile Updater stammen aus einem nachgewiesenen GNU-Build. Der offizielle Schlüssel ist vom Entwicklungsschlüssel getrennt. Alle Verwaltungs- und Geräteprozesse einer Installation verwenden denselben offiziellen Schlüsselring. Die native Abnahme umfasst Erstaufnahme, Ablehnung einer Entwicklungssignatur, automatisches Folgeupdate unter derselben Geräteidentität und einen genehmigten Skriptauftrag. MSVC bleibt ein optionales weiteres Buildziel. diff --git a/crates/server/src/agent_updates.rs b/crates/server/src/agent_updates.rs index 73520c1..8845b93 100644 --- a/crates/server/src/agent_updates.rs +++ b/crates/server/src/agent_updates.rs @@ -588,11 +588,14 @@ async fn installed( ) -> Result { let (tenant, agent) = device(&s, peer, &headers).await?; let mut tx = rmm_persistence::tenant_tx(&s.pool, tenant).await?; - let row = sqlx::query("SELECT reported_agent_version,connection_generation,last_contact_at FROM agent_installations WHERE agent_id=$1 AND revoked_at IS NULL").bind(agent).fetch_one(&mut *tx).await?; + let row = sqlx::query("SELECT asset_id,enrollment_generation,assignment_version,capabilities,reported_agent_version,connection_generation,last_contact_at FROM agent_installations WHERE agent_id=$1 AND revoked_at IS NULL").bind(agent).fetch_one(&mut *tx).await?; tx.commit().await?; Ok(( [("cache-control", "private, no-store")], - Json(json!({"agent_id":agent, + Json(json!({"tenant_id":tenant,"asset_id":row.get::("asset_id"),"agent_id":agent, + "enrollment_generation":row.get::("enrollment_generation"), + "assignment_version":row.get::("assignment_version"), + "capabilities":row.get::("capabilities"), "agent_version":row.get::,_>("reported_agent_version"), "connection_generation":row.get::("connection_generation"), "last_contact_at":row.get::>,_>("last_contact_at")})), @@ -1256,19 +1259,17 @@ mod tests { } } #[test] - fn plan_request_accepts_release_id_but_never_user_supplied_local_bindings() { + fn update_releases_are_not_device_job_plans() { let mut value = json!({"tenant_id":"11111111-1111-4111-8111-111111111111","action":"update_agent","targets":{"asset_ids":["11111111-1111-4111-8111-111111111112"]}, "parameters":{"release_id":"11111111-1111-4111-8111-111111111113","execution_identity":"root","timeout_seconds":600,"max_output_bytes":65536}, "schedule":{"not_before":"2030-01-01T12:00:00Z","start_before":"2030-01-01T12:10:00Z","offline_policy":"wait_until_deadline"},"rollout":{"max_parallel":1,"halt_after_failures":1},"reason":"codec only"}); - let parsed: crate::jobs::PlanRequest = serde_json::from_value(value.clone()).unwrap(); - assert!(matches!(parsed, crate::jobs::PlanRequest::AgentUpdate(_))); - // The old synchronous resolver cannot manufacture local state. - assert!( - parsed - .resolve(Uuid::parse_str(value["tenant_id"].as_str().unwrap()).unwrap()) - .is_err() - ); - value["parameters"]["predecessor"] = json!({"installed_record_sha256":"00".repeat(32)}); - assert!(serde_json::from_value::(value).is_err()); + let tenant = Uuid::parse_str(value["tenant_id"].as_str().unwrap()).unwrap(); + for local_binding in [false, true] { + if local_binding { + value["parameters"]["predecessor"] = json!({"installed_record_sha256":"00".repeat(32)}); + } + let parsed: crate::jobs::PlanRequest = serde_json::from_value(value.clone()).unwrap(); + assert_eq!(parsed.resolve(tenant).err().unwrap().1, "SCRIPT_ACTION_REQUIRED"); + } } } diff --git a/crates/server/src/bootstrap/lifecycle.py b/crates/server/src/bootstrap/lifecycle.py index 7e7c6a2..9207887 100644 --- a/crates/server/src/bootstrap/lifecycle.py +++ b/crates/server/src/bootstrap/lifecycle.py @@ -569,10 +569,12 @@ def run_agent(): RMM_RELEASE_LOCK=str(ROOT / 'release.lock'), RMM_INSTALLED_RELEASE_VERSION=read(ROOT / 'current/manifest.json')['version']) folder = active_folder() + os.environ.pop('RMM_SCRIPT_HELPER_RELEASE', None) if (folder / 'script-pin.json').is_file() and helper_state() in ('enabled', 'enabled-runtime'): - os.environ.update(RMM_FULL_MAINTENANCE_HELPER_SOCKET=str(HELPER_SOCKET), - RMM_FULL_MAINTENANCE_POLICY_FILE=str(folder / 'script-pin.json'), - RMM_SCRIPT_HELPER_RELEASE=folder.name) + pins = {'RMM_FULL_MAINTENANCE_HELPER_SOCKET': str(HELPER_SOCKET), + 'RMM_FULL_MAINTENANCE_POLICY_FILE': str(folder / 'script-pin.json')} + if all(os.environ.get(name, value) == value for name, value in pins.items()): + os.environ.update(pins, RMM_SCRIPT_HELPER_RELEASE=folder.name) exe = str(folder / 'agent') os.execv(exe, [exe]) @@ -681,7 +683,7 @@ def main(): elif args.action == 'run-helper': require(os.geteuid() == 0, 'privileged script helper service required') folder = active_folder() - os.environ['RMM_HELPER_CONFIG'] = str(folder / 'script-helper.json') + os.environ.setdefault('RMM_HELPER_CONFIG', str(folder / 'script-helper.json')) os.execv(folder / 'helper', [str(folder / 'helper')]) elif args.action == 'run-agent': run_agent() diff --git a/crates/server/src/jobs.rs b/crates/server/src/jobs.rs index 6f119d9..39b0e81 100644 --- a/crates/server/src/jobs.rs +++ b/crates/server/src/jobs.rs @@ -128,42 +128,38 @@ pub struct PlanInput { #[serde(default)] pub artifact_ids: Vec, } -#[derive(Clone, Deserialize, schemars::JsonSchema)] +#[derive(Clone, Deserialize)] #[serde(untagged)] pub enum PlanRequest { - AgentUpdate(Box), - Typed(Box), Web(Box), + // Earlier SDKs sent the fixed script action instead of platform variants. + Typed(Box), + Retired { + tenant_id: Uuid, + #[serde(rename = "action", deserialize_with = "retired_action")] + _action: (), + }, } + +fn retired_action<'de, D: serde::Deserializer<'de>>(d: D) -> std::result::Result<(), D::Error> { + if String::deserialize(d)? == "run_script" { + return Err(serde::de::Error::custom("invalid run_script parameters")); + } + Ok(()) +} + #[derive(Clone, Deserialize, schemars::JsonSchema)] -#[serde(deny_unknown_fields)] -pub struct AgentUpdatePlanInput { - tenant_id: Uuid, - action: AgentUpdateRequestAction, - targets: Targets, - parameters: AgentUpdateParameters, - schedule: WebSchedule, - rollout: Rollout, - reason: String, -} -#[derive(Clone, Deserialize, schemars::JsonSchema)] -pub enum AgentUpdateRequestAction { - #[serde(rename = "update_agent")] - UpdateAgent, -} -#[derive(Clone, Deserialize, schemars::JsonSchema)] -#[serde(deny_unknown_fields)] -struct AgentUpdateParameters { - release_id: Uuid, - execution_identity: String, - timeout_seconds: u32, - max_output_bytes: u32, +enum ScriptActionName { + #[serde(rename = "run_script")] + RunScript, } + #[derive(Clone, Deserialize, schemars::JsonSchema)] #[serde(deny_unknown_fields)] pub struct WebPlanInput { tenant_id: Uuid, - action: String, + #[serde(rename = "action")] + _action: ScriptActionName, targets: Targets, parameters: WebParameters, schedule: WebSchedule, @@ -207,45 +203,25 @@ struct WebParameters { execution_identity: String, timeout_seconds: u32, max_output_bytes: u32, - variants: Option>, + variants: Vec, arguments: Option>, expected_stdout: Option, - scope: Option, - unit: Option, - state: Option, - since: Option>, - until: Option>, - max_lines: Option, - provider: Option, - package: Option, - version: Option, - architecture: Option, - recipe_version: Option, - recipe_id: Option, - apt_manifest: Option, - #[serde( - default, - deserialize_with = "rmm_domain::jobs::deserialize_windows_msi_manifest" - )] - #[schemars(with = "rmm_domain::windows_execution::ResolvedWindowsMsi")] - windows_msi_manifest: Option>, - installation_context: Option, - packages: Option>, - reboot_policy: Option, - reason: Option, - dependency_group: Option, - reconnect_timeout_seconds: Option, } + impl PlanRequest { pub fn resolve(self, tenant: Uuid) -> Result { let w = match self { - Self::AgentUpdate(_) => { - return Err(Error( - StatusCode::BAD_REQUEST, - "AGENT_UPDATE_RELEASE_ID_REQUIRED", - )); + Self::Typed(input) => { + require_script(&input.action)?; + return Ok(*input); + } + Self::Retired { tenant_id, .. } => { + return Err(if tenant_id == tenant { + fail("SCRIPT_ACTION_REQUIRED") + } else { + missing() + }); } - Self::Typed(t) => return Ok(*t), Self::Web(w) => *w, }; if w.tenant_id != tenant { @@ -254,105 +230,21 @@ impl PlanRequest { if w.schedule.offline_policy != "wait_until_deadline" { return Err(fail("POLICY_DENIED")); } - let parameters = serde_json::to_value(&w.parameters).map_err(Error::from)?; - if w.action != "run_script" && w.parameters.variants.is_some() { - return Err(Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR")); - } let p = w.parameters; - if p.windows_msi_manifest.is_some() && w.action != "ensure_package" { - return Err(Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR")); - } - let required = - |value: Option| value.ok_or(Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR")); - let action = match w.action.as_str() { - "run_script" => { - let variants = p - .variants - .as_ref() - .ok_or(Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR"))?; - validate_variants(variants)?; - let v = &variants[0]; - Action::RunScript { - interpreter: v.interpreter.clone(), - script_utf8: v.script_utf8.clone(), - arguments: p.arguments.clone().unwrap_or_default(), - expected_stdout: p.expected_stdout.clone(), - windows_execution_profile: v.windows_execution_profile, - privileged_script_profile: p.privileged_script_profile, - } - } - "refresh_inventory" => Action::RefreshInventory { - scope: required(p.scope)?, - }, - "query_logs" => Action::QueryLogs { - unit: required(p.unit)?, - since: p - .since - .ok_or(Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR"))?, - until: p - .until - .ok_or(Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR"))?, - max_lines: p - .max_lines - .ok_or(Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR"))?, - }, - "set_service_state" => Action::SetServiceState { - unit: required(p.unit)?, - state: required(p.state)?, - }, - "ensure_package" => Action::EnsurePackage { - provider: required(p.provider)?, - package: required(p.package)?, - version: required(p.version)?, - architecture: required(p.architecture)?, - recipe_version: required(p.recipe_version)?, - installation_context: required(p.installation_context)?, - recipe_id: p.recipe_id, - apt_manifest: p.apt_manifest, - windows_msi_manifest: p.windows_msi_manifest, - }, - "apply_updates" => Action::ApplyUpdates { - provider: required(p.provider)?, - packages: p - .packages - .ok_or(Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR"))?, - reboot_policy: required(p.reboot_policy)?, - apt_manifest: p.apt_manifest, - }, - "apt_native_acceptance" => Action::AptNativeAcceptance { - recipe_id: required(p.recipe_id)?, - recipe_version: required(p.recipe_version)?, - apt_manifest: p - .apt_manifest - .ok_or(Error(StatusCode::BAD_REQUEST, "APT_MANIFEST_REQUIRED"))?, - }, - "reboot" => Action::Reboot { - reason: required(p.reason)?, - dependency_group: required(p.dependency_group)?, - reconnect_timeout_seconds: p - .reconnect_timeout_seconds - .ok_or(Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR"))?, - }, - _ => return Err(fail("UNSUPPORTED_CAPABILITY")), + validate_variants(&p.variants)?; + let first = &p.variants[0]; + let action = Action::RunScript { + interpreter: first.interpreter.clone(), + script_utf8: first.script_utf8.clone(), + arguments: p.arguments.unwrap_or_default(), + expected_stdout: p.expected_stdout, + windows_execution_profile: first.windows_execution_profile, + privileged_script_profile: p.privileged_script_profile, }; - // Reject irrelevant non-null fields instead of silently discarding an - // effect that the browser displayed. Common limits bind into JobPayload. - let action_view = serde_json::to_value(&action)?; - for (key, value) in parameters.as_object().into_iter().flatten() { - if !value.is_null() - && !matches!( - key.as_str(), - "execution_identity" | "timeout_seconds" | "max_output_bytes" | "variants" - ) - && action_view.get(key).is_none() - { - return Err(Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR")); - } - } Ok(PlanInput { targets: w.targets, action, - script_variants: p.variants.unwrap_or_default(), + script_variants: p.variants, execution_identity: p.execution_identity, schedule: Schedule { not_before: w.schedule.not_before, @@ -366,68 +258,25 @@ impl PlanRequest { }) } } -/// Both HTTP and MCP resolve update jobs only from a fixed catalog release and -/// saved authenticated per-device observations. Caller-supplied local pins are -/// never an alternative route to the typed immutable execution payload. +/// HTTP and MCP prepare the same tenant-scoped, immutable script plans. pub async fn plan_request( state: &crate::State, p: &Principal, tenant: Uuid, request: PlanRequest, ) -> Result { - let PlanRequest::AgentUpdate(input) = request else { - return plan(state, p, tenant, request.resolve(tenant)?).await; - }; scope(p, tenant, true)?; - if input.tenant_id != tenant { - return Err(missing()); - } - if input.schedule.offline_policy != "wait_until_deadline" - || input.parameters.release_id.is_nil() - || input.targets.asset_ids.is_empty() - || input.targets.asset_ids.len() > 100 - { - return Err(fail("VALIDATION_ERROR")); - } - let _ = &input.action; - let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant).await?; - crate::permissions::require_principal(&mut tx, p, "operations:plan").await?; - crate::permissions::require_principal(&mut tx, p, "updates:apply").await?; - let mut updates = std::collections::BTreeMap::new(); - for asset in &input.targets.asset_ids { - let update = - crate::agent_updates::resolve_target(&mut tx, *asset, input.parameters.release_id) - .await?; - if update.execution_identity() != Some(input.parameters.execution_identity.as_str()) { - return Err(fail("EXECUTION_IDENTITY_DENIED")); - } - updates.insert(*asset, update); - } - tx.commit().await?; - let first = updates - .values() - .next() - .ok_or_else(|| fail("NOT_FOUND"))? - .clone(); - let resolved = PlanInput { - targets: input.targets, - action: Action::UpdateAgent { - update: Box::new(first), - }, - script_variants: Vec::new(), - execution_identity: input.parameters.execution_identity, - schedule: Schedule { - not_before: input.schedule.not_before, - start_before: input.schedule.start_before, - }, - max_runtime_seconds: input.parameters.timeout_seconds, - max_output_bytes: input.parameters.max_output_bytes, - rollout: input.rollout, - reason: input.reason, - artifact_ids: Vec::new(), - }; - plan_resolved(state, p, tenant, resolved, Some(updates), None).await + plan(state, p, tenant, request.resolve(tenant)?).await } + +fn require_script(action: &Action) -> Result<()> { + if matches!(action, Action::RunScript { .. }) { + Ok(()) + } else { + Err(fail("SCRIPT_ACTION_REQUIRED")) + } +} + fn validate_variants(variants: &[Variant]) -> Result<()> { if variants.is_empty() || variants.len() > 2 { return Err(fail("AMBIGUOUS_TARGET")); @@ -531,25 +380,17 @@ pub async fn plan( tenant: Uuid, input: PlanInput, ) -> Result { - if matches!(input.action, Action::UpdateAgent { .. }) { - return Err(Error( - StatusCode::BAD_REQUEST, - "AGENT_UPDATE_RELEASE_ID_REQUIRED", - )); - } - plan_resolved(state, p, tenant, input, None, None).await + plan_resolved(state, p, tenant, input, None).await } pub(crate) async fn plan_resolved( state: &crate::State, p: &Principal, tenant: Uuid, input: PlanInput, - updates: Option< - std::collections::BTreeMap, - >, script_revision: Option, ) -> Result { scope(p, tenant, true)?; + require_script(&input.action)?; let now = Utc::now(); if input.targets.asset_ids.is_empty() || input.targets.asset_ids.len() > 100 @@ -574,33 +415,6 @@ pub(crate) async fn plan_resolved( { return Err(Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR")); } - if matches!( - input.action, - Action::AptNativeAcceptance { .. } - | Action::EnsurePackage { - apt_manifest: Some(_), - .. - } - | Action::ApplyUpdates { - apt_manifest: Some(_), - .. - } - ) && input.execution_identity != "root" - { - return Err(Error(StatusCode::FORBIDDEN, "ROOT_IDENTITY_REQUIRED")); - } - if input.action.windows_msi().is_some() - && (input.execution_identity != "system" || !input.artifact_ids.is_empty()) - { - return Err(Error( - StatusCode::BAD_REQUEST, - "WINDOWS_MSI_EXACT_ARTIFACT_REQUIRED", - )); - } - // Conservative policy: reboot is always serial, no provider-triggered reboot. - if matches!(input.action, Action::Reboot { .. }) && input.rollout.max_parallel != 1 { - return Err(fail("POLICY_DENIED")); - } let mut ids = input.targets.asset_ids.clone(); ids.sort(); ids.dedup(); @@ -610,25 +424,7 @@ pub(crate) async fn plan_resolved( for permission in execution_permissions(&input.action, &input.execution_identity) { crate::permissions::require_principal(&mut tx, p, permission).await?; } - let recipe_references = crate::catalog::references(&mut tx, &input.action).await?; - let artifacts = if let Action::UpdateAgent { update } = &input.action { - if !input.artifact_ids.is_empty() { - return Err(fail("AGENT_UPDATE_EXACT_ARTIFACT_REQUIRED")); - } - crate::agent_updates::resolve_artifacts( - &mut tx, - tenant, - &update - .manifest() - .map_err(|_| fail("INVALID_AGENT_RELEASE"))? - .artifacts, - ) - .await? - } else if input.action.windows_msi().is_some() { - crate::windows_msi_catalog::automatic_artifacts(&mut tx, tenant, &input.action).await? - } else { - crate::catalog::resolve_artifacts(&mut tx, tenant, &input.artifact_ids).await? - }; + let artifacts = crate::catalog::resolve_artifacts(&mut tx, tenant, &input.artifact_ids).await?; let mut jobs = Vec::new(); for asset in ids { let rows=sqlx::query("SELECT agent_id,enrollment_generation,assignment_version,capabilities FROM agent_installations WHERE asset_id=$1 AND revoked_at IS NULL ORDER BY agent_id FOR SHARE").bind(asset).fetch_all(&mut *tx).await?; @@ -641,18 +437,7 @@ pub(crate) async fn plan_resolved( } let row = &rows[0]; let caps = capabilities(row.get("capabilities"))?; - let action = if let Some(updates) = &updates { - Action::UpdateAgent { - update: Box::new( - updates - .get(&asset) - .ok_or_else(|| fail("AGENT_UPDATE_STATE_NOT_CONFIGURED"))? - .clone(), - ), - } - } else { - target_action(&input, &caps)? - }; + let action = target_action(&input, &caps)?; if !action.valid_job_limits(input.max_runtime_seconds, input.max_output_bytes) { return Err(fail("VALIDATION_ERROR")); } @@ -709,7 +494,7 @@ pub(crate) async fn plan_resolved( jobs, max_parallel: input.rollout.max_parallel, halt_after_failures: input.rollout.halt_after_failures, - recipe_references, + recipe_references: Vec::new(), artifact_references, script_revision, }; @@ -807,6 +592,7 @@ pub(crate) async fn authorize_approved_job( job: &JobPayload, row: &sqlx::postgres::PgRow, ) -> Result<()> { + require_script(&job.action)?; let participants = JobParticipants { planner: &plan.principal, submitter: row.get("submitter"), @@ -966,7 +752,8 @@ pub async fn submit( let request_hash = hash(id.as_bytes()); let (plan, _, _) = load_plan(&mut tx, id).await?; for job in &plan.jobs { - for permission in execution_permissions(&job.payload.action, &job.payload.execution_identity) + for permission in + execution_permissions(&job.payload.action, &job.payload.execution_identity) { crate::permissions::require_principal(&mut tx, p, permission).await?; } @@ -993,6 +780,9 @@ pub async fn submit( tx.commit().await?; return operation(state, p, tenant, op).await; } + for job in &plan.jobs { + require_script(&job.payload.action)?; + } recheck(&mut tx, &plan).await?; let op = Uuid::new_v4(); sqlx::query("INSERT INTO approval_requests(tenant_id,operation_id,plan_id,principal,idempotency_key,request_hash) VALUES($1,$2,$3,$4,$5,$6)").bind(tenant).bind(op).bind(id).bind(&p.name).bind(&input.idempotency_key).bind(&request_hash).execute(&mut *tx).await?; @@ -1029,8 +819,11 @@ pub(crate) async fn recheck_approval( submitter, approver: &approver.name, }; - participants.require_roles(state, tx, plan.tenant_id).await?; + participants + .require_roles(state, tx, plan.tenant_id) + .await?; for job in &plan.jobs { + require_script(&job.payload.action)?; if execution_permissions(&job.payload.action, &job.payload.execution_identity) .any(|permission| !approver.permits_scope(permission)) { @@ -1118,8 +911,15 @@ pub async fn requester_enabled( if name.starts_with("mcp:") { crate::mcp_tokens::issuer_enabled(state, tx, name).await } else if name.starts_with("local:") { - let Some(home)=state.auth.local.as_ref().and_then(|local|local.home(name)) else {return Ok(false);}; - sqlx::query_scalar("SELECT $3=ANY(local_customer_tenants($1,$2))").bind(name).bind(home).bind(tenant).fetch_one(&mut **tx).await + let Some(home) = state.auth.local.as_ref().and_then(|local| local.home(name)) else { + return Ok(false); + }; + sqlx::query_scalar("SELECT $3=ANY(local_customer_tenants($1,$2))") + .bind(name) + .bind(home) + .bind(tenant) + .fetch_one(&mut **tx) + .await } else { Ok(state.auth.operator_enabled(name, tenant)) } @@ -1537,31 +1337,45 @@ mod windows_contract_tests { assert!(target_action(&i, &["windows.base/1".into()]).is_err()); } #[test] - fn fixed_windows_log_web_contract_denies_extra_source_parameters() { + fn new_plans_accept_only_scripts_in_both_wire_formats() { let tenant = Uuid::new_v4(); - let now = Utc::now(); - let value = json!({"tenant_id":tenant,"action":"query_logs","targets":{"asset_ids":[Uuid::new_v4()]},"parameters":{"execution_identity":"agent_service","timeout_seconds":30,"max_output_bytes":4096,"unit":WINDOWS_EVENT_LOG_FIXTURE_SOURCE,"since":now-Duration::hours(1),"until":now,"max_lines":1000},"schedule":{"not_before":now,"start_before":now+Duration::minutes(10),"offline_policy":"wait_until_deadline"},"rollout":{"max_parallel":1,"halt_after_failures":1},"reason":"fixed source"}); - let input = serde_json::from_value::(value.clone()) - .unwrap() - .resolve(tenant) - .unwrap(); - assert!(input.action.is_windows_event_log_fixture()); - assert!(input.action.validate()); - assert!( - input - .action - .valid_job_limits(input.max_runtime_seconds, input.max_output_bytes) + let typed = serde_json::to_value(input()).unwrap(); + let request: PlanRequest = serde_json::from_value(typed.clone()).unwrap(); + assert!(matches!( + request.resolve(tenant).unwrap().action, + Action::RunScript { .. } + )); + let mut retired = typed; + retired["action"] = json!({"action":"refresh_inventory", "scope":"linux.base"}); + let request: PlanRequest = serde_json::from_value(retired).unwrap(); + assert_eq!( + request.resolve(tenant).err().unwrap().1, + "SCRIPT_ACTION_REQUIRED" ); - assert!(input.script_variants.is_empty()); - for field in ["channel", "provider", "xpath", "bookmark"] { - let mut bad = value.clone(); - bad["parameters"][field] = json!("arbitrary"); - assert!( - serde_json::from_value::(bad) - .map(|request| request.resolve(tenant).is_err()) - .unwrap_or(true) + + for action in [ + "reboot", + "query_logs", + "set_service_state", + "update_agent", + "future-action", + ] { + let old: PlanRequest = serde_json::from_value( + json!({"tenant_id":tenant, "action":action, "parameters":{}}), + ) + .unwrap(); + assert_eq!( + old.clone().resolve(tenant).err().unwrap().1, + "SCRIPT_ACTION_REQUIRED" ); + assert_eq!(old.resolve(Uuid::new_v4()).err().unwrap().1, "NOT_FOUND"); } + assert!( + serde_json::from_value::( + json!({"tenant_id":tenant, "action":"run_script", "parameters":{"unit":"x"}}) + ) + .is_err() + ); } #[test] fn full_maintenance_web_profile_is_action_wide_strict_and_identity_bound() { @@ -1664,6 +1478,58 @@ mod windows_contract_tests { } assert!(serde_json::from_value::(json!({"execution_identity":"agent_service", "timeout_seconds":60, "max_output_bytes":4096, "windows_execution_profile":"powershell_51_remote_signed"})).is_err()); } + // Restore a synthetic historical plan row for read/recheck tests. No job, approval, + // outbox entry or start grant is created; current API callers cannot create such a plan. + async fn historical_fixture( + state: &crate::State, + template: &PlanPayload, + input: &PlanInput, + ) -> PlanPayload { + let mut plan = template.clone(); + plan.plan_id = Uuid::new_v4(); + plan.jobs + .retain(|job| job.payload.asset_id == input.targets.asset_ids[0]); + assert_eq!(plan.jobs.len(), 1); + let job = &mut plan.jobs[0]; + job.payload.job_id = Uuid::new_v4(); + job.payload.attempt_id = Uuid::new_v4(); + job.payload.action = input.action.clone(); + job.payload.execution_identity = input.execution_identity.clone(); + job.payload.max_runtime_seconds = input.max_runtime_seconds; + job.payload.max_output_bytes = input.max_output_bytes; + job.script_sha256 = None; + job.job_payload_hash = hash(&encode(&job.payload).unwrap()); + let mut tx = rmm_persistence::tenant_tx(&state.pool, plan.tenant_id) + .await + .unwrap(); + plan.recipe_references = crate::catalog::references(&mut tx, &input.action) + .await + .unwrap(); + if input.action.windows_msi().is_some() { + let artifacts = crate::windows_msi_catalog::automatic_artifacts( + &mut tx, + plan.tenant_id, + &input.action, + ) + .await + .unwrap(); + plan.artifact_references = artifacts + .into_iter() + .map(|artifact| JobArtifactReference { + job_id: job.payload.job_id, + attempt_id: job.payload.attempt_id, + artifact, + }) + .collect(); + } + let bytes = encode(&plan).unwrap(); + sqlx::query("INSERT INTO operation_plans(tenant_id,plan_id,principal,payload,plan_hash,expires_at) VALUES($1,$2,$3,$4,$5,$6)") + .bind(plan.tenant_id).bind(plan.plan_id).bind(&plan.principal).bind(&bytes).bind(hash(&bytes)).bind(input.schedule.start_before) + .execute(&mut *tx).await.unwrap(); + tx.commit().await.unwrap(); + plan + } + #[tokio::test] #[ignore = "requires dedicated isolated PostgreSQL; tests/windows_plan_database.py"] async fn windows_plan_caps_persisted_database() { @@ -1824,8 +1690,10 @@ mod windows_contract_tests { .execute(&admin) .await .unwrap(); - crate::script_library::tests::revision_plan_contract(&state, &principal, assets[0], assets[1]) - .await; + crate::script_library::tests::revision_plan_contract( + &state, &principal, assets[0], assets[1], + ) + .await; let view = plan(&state, &principal, tenant, profiled).await.unwrap(); let profile_id = Uuid::parse_str(view["plan_id"].as_str().unwrap()).unwrap(); let bytes: Vec = @@ -1914,16 +1782,9 @@ mod windows_contract_tests { .await .unwrap_err() .1, - "FORBIDDEN" + "SCRIPT_ACTION_REQUIRED" ); sqlx::query("UPDATE memberships SET permissions=array_append(permissions,'logs:read') WHERE principal=$1").bind(&principal.name).execute(&admin).await.unwrap(); - assert_eq!( - plan(&state, &principal, tenant, logs.clone()) - .await - .unwrap_err() - .1, - "UNSUPPORTED_CAPABILITY" - ); let mut log_caps = windows_caps.as_array().unwrap().clone(); log_caps.extend([ json!("query_logs"), @@ -1935,21 +1796,14 @@ mod windows_contract_tests { .execute(&admin) .await .unwrap(); - let view = plan(&state, &principal, tenant, logs).await.unwrap(); - let log_id = Uuid::parse_str(view["plan_id"].as_str().unwrap()).unwrap(); - let bytes: Vec = - sqlx::query_scalar("SELECT payload FROM operation_plans WHERE plan_id=$1") - .bind(log_id) - .fetch_one(&admin) - .await - .unwrap(); - let log_bound: PlanPayload = serde_json::from_slice(&bytes).unwrap(); + let log_bound = historical_fixture(&state, &bound, &logs).await; + let log_id = log_bound.plan_id; let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant) .await .unwrap(); recheck(&mut tx, &log_bound).await.unwrap(); tx.rollback().await.unwrap(); - let pending = submit( + let blocked = submit( &state, &principal, tenant, @@ -1959,9 +1813,8 @@ mod windows_contract_tests { }, ) .await - .unwrap(); - assert_eq!(pending["approval_state"], "pending_approval"); - assert_eq!(pending["job_count"], 0); + .unwrap_err(); + assert_eq!(blocked.1, "SCRIPT_ACTION_REQUIRED"); let mut changed = log_bound.clone(); if let Action::QueryLogs { max_lines, .. } = &mut changed.jobs[0].payload.action { *max_lines = 999; @@ -2122,21 +1975,14 @@ mod windows_contract_tests { package.action = crate::windows_msi_catalog::test_action(manifest.clone()); package.max_runtime_seconds = 30; package.max_output_bytes = 4096; - let mut extra = package.clone(); - extra.artifact_ids = vec![artifact_id]; assert_eq!( - plan(&state, &principal, tenant, extra).await.unwrap_err().1, - "WINDOWS_MSI_EXACT_ARTIFACT_REQUIRED" - ); - let view = plan(&state, &principal, tenant, package).await.unwrap(); - let package_id = Uuid::parse_str(view["plan_id"].as_str().unwrap()).unwrap(); - let raw: Vec = - sqlx::query_scalar("SELECT payload FROM operation_plans WHERE plan_id=$1") - .bind(package_id) - .fetch_one(&admin) + plan(&state, &principal, tenant, package.clone()) .await - .unwrap(); - let fixed: PlanPayload = serde_json::from_slice(&raw).unwrap(); + .unwrap_err() + .1, + "SCRIPT_ACTION_REQUIRED" + ); + let fixed = historical_fixture(&state, &bound, &package).await; assert_eq!(fixed.artifact_references.len(), 1); assert_eq!( fixed.artifact_references[0].artifact.artifact_id, @@ -2163,19 +2009,18 @@ mod windows_contract_tests { assert!(recheck(&mut tx, &bad).await.is_err()); tx.rollback().await.unwrap(); } - let pending = submit( + let blocked = submit( &state, &principal, tenant, - package_id, + fixed.plan_id, Submit { idempotency_key: "fixed-msi-metadata".into(), }, ) .await - .unwrap(); - assert_eq!(pending["approval_state"], "pending_approval"); - assert_eq!(pending["job_count"], 0); + .unwrap_err(); + assert_eq!(blocked.1, "SCRIPT_ACTION_REQUIRED"); sqlx::query("UPDATE memberships SET permissions=array_remove(permissions,'system:execute') WHERE tenant_id=$1 AND principal=$2").bind(tenant).bind(&principal.name).execute(&admin).await.unwrap(); let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant) .await diff --git a/crates/server/src/local_auth.rs b/crates/server/src/local_auth.rs index 1be5bb9..08146bd 100644 --- a/crates/server/src/local_auth.rs +++ b/crates/server/src/local_auth.rs @@ -486,8 +486,8 @@ mod tests { assert_eq!(directory["items"].as_array().unwrap().len(), 1); assert_eq!(directory["items"][0]["tenant_id"], a.to_string()); let now = Utc::now(); - let forbidden_plan = json!({"tenant_id":b,"action":"refresh_inventory","targets":{"asset_ids":[asset]}, - "parameters":{"execution_identity":"agent_service","timeout_seconds":60,"max_output_bytes":4096,"scope":"base"}, + let forbidden_plan = json!({"tenant_id":b,"action":"run_script","targets":{"asset_ids":[asset]}, + "parameters":{"execution_identity":"agent_service","timeout_seconds":60,"max_output_bytes":4096,"variants":[{"os_family":"linux","interpreter":"posix_sh","encoding":"utf-8","script_utf8":":\n"}]}, "schedule":{"not_before":now,"start_before":now+chrono::Duration::minutes(5),"offline_policy":"wait_until_deadline"}, "rollout":{"max_parallel":1,"halt_after_failures":1},"reason":"test customer authorization"}); for request in [ diff --git a/crates/server/src/managed_scripts.rs b/crates/server/src/managed_scripts.rs index b81c2f7..5afa73c 100644 --- a/crates/server/src/managed_scripts.rs +++ b/crates/server/src/managed_scripts.rs @@ -2,9 +2,14 @@ //! Plan submission, interactive approval and signed start grants are unchanged. use crate::{jobs::Error, root_policy::RootScope, windows_policy::SystemScope}; use axum::http::StatusCode; -use rmm_domain::jobs::{Action, JobPayload}; +use rmm_domain::{ + agent_update::{ArtifactRole, Platform, ReleaseManifest, digest}, + jobs::{Action, FULL_MAINTENANCE_CAPABILITY, JobPayload}, +}; use serde::Deserialize; +use sqlx::{Postgres, Transaction}; use std::{fs, os::unix::fs::MetadataExt, path::Path}; +use uuid::Uuid; #[derive(Deserialize)] #[serde(deny_unknown_fields)] @@ -12,6 +17,76 @@ struct Policy { schema_version: u8, linux: Vec, windows: Vec, + #[serde(default)] + release_anchors: Vec, +} + +/// Operator-pinned canonical bytes of an already authorized local policy. +/// A signed pair changes only the two image digests and the Windows release directory. +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct ReleaseAnchor { + agent_id: Uuid, + release_id: Uuid, + agent_sha256: String, + helper_sha256: String, + policy_json: String, +} + +impl ReleaseAnchor { + fn policy_for(&self, manifest: &ReleaseManifest) -> Option { + if self.policy_json.len() > 8192 + || self.release_id.is_nil() + || !digest(&self.agent_sha256) + || !digest(&self.helper_sha256) + || self.agent_sha256 == self.helper_sha256 + { + return None; + } + let next = |role| { + manifest + .artifacts + .iter() + .find(|a| a.role == role) + .map(|a| a.sha256.as_str()) + }; + let mut raw = self.policy_json.clone(); + let mut replace = |from: String, to: String, count| { + if raw.matches(&from).count() != count { + return None; + } + raw = raw.replace(&from, &to); + Some(()) + }; + let field = |name: &str, value: &str| format!(r#""{name}":"{value}""#); + match manifest.platform { + Platform::LinuxX64 => replace( + field("helper_binary_sha256", &self.helper_sha256), + field("helper_binary_sha256", next(ArtifactRole::Helper)?), + 1, + )?, + Platform::WindowsGnuX64 => { + replace( + field("binary_sha256", &self.agent_sha256), + field("binary_sha256", next(ArtifactRole::Agent)?), + 1, + )?; + replace( + field("binary_sha256", &self.helper_sha256), + field("binary_sha256", next(ArtifactRole::Helper)?), + 1, + )?; + let directory = |release| format!(r"\\releases\\{release}\\"); + replace( + directory(self.release_id), + directory(manifest.release_id), + 2, + )?; + } + _ => return None, + } + Some(rmm_domain::jobs::hash(raw.as_bytes())) + } } fn invalid() -> Error { @@ -24,19 +99,72 @@ impl Policy { || !job.action.full_maintenance() || !job.action.validate() || !job.action.available_for(&job.execution_identity, caps) - || !job.action.valid_job_limits(job.max_runtime_seconds, job.max_output_bytes) + || !job + .action + .valid_job_limits(job.max_runtime_seconds, job.max_output_bytes) { return false; } match job.execution_identity.as_str() { - "root" => self.linux.iter().any(|scope| scope.permits(principal, job, caps, None)), - "system" => self.windows.iter().any(|scope| scope.permits(principal, job, caps, false, true, false)), + "root" => self + .linux + .iter() + .any(|scope| scope.permits(principal, job, caps, None)), + "system" => self + .windows + .iter() + .any(|scope| scope.permits(principal, job, caps, false, true, false)), _ => false, } } } -pub(crate) fn permits(principal: &str, job: &JobPayload, caps: &[String]) -> Result { +fn binding_error() -> Error { + Error(StatusCode::CONFLICT, "SCRIPT_HELPER_BINDING_INVALID") +} + +// Multiple helper roles may coexist on older clients. For the release-managed +// script profile we require exactly one unambiguous release, policy and binary. +fn single_value<'a>(caps: &'a [String], prefix: &str) -> Result<&'a str, Error> { + let mut values = caps.iter().filter_map(|c| c.strip_prefix(prefix)); + let value = values.next().ok_or_else(binding_error)?; + if value.is_empty() || values.next().is_some() { + return Err(binding_error()); + } + Ok(value) +} + +fn check_pair( + manifest: &ReleaseManifest, + version: Option<&str>, + identity: &str, + caps: &[String], +) -> Result<(), Error> { + let platform = match identity { + "root" => Platform::LinuxX64, + "system" => Platform::WindowsGnuX64, + _ => return Err(binding_error()), + }; + let binary = single_value(caps, "helper.binary.sha256:")?; + if version != Some(manifest.version.as_str()) + || platform != manifest.platform + || !digest(single_value(caps, "helper.policy.sha256:")?) + || !manifest + .artifacts + .iter() + .any(|a| a.role == ArtifactRole::Helper && a.sha256 == binary) + { + return Err(binding_error()); + } + Ok(()) +} + +pub(crate) async fn permits( + tx: &mut Transaction<'_, Postgres>, + principal: &str, + job: &JobPayload, + caps: &[String], +) -> Result { if !job.action.full_maintenance() { return Ok(false); } @@ -53,9 +181,142 @@ pub(crate) fn permits(principal: &str, job: &JobPayload, caps: &[String]) -> Res let policy: Policy = serde_json::from_slice(&bytes).map_err(|_| invalid())?; if policy.schema_version != 1 || policy.linux.len() + policy.windows.len() > 64 + || policy.release_anchors.len() > 64 + || policy + .release_anchors + .iter() + .any(|a| a.policy_json.len() > 8192) || !policy.windows.iter().all(SystemScope::valid) { return Err(invalid()); } - Ok(policy.permits(principal, job, caps)) + let direct = policy.permits(principal, job, caps); + if !caps + .iter() + .any(|cap| cap.starts_with("script.helper.release:")) + { + return Ok(direct); + } + { + let release = Uuid::parse_str(single_value(caps, "script.helper.release:")?) + .map_err(|_| binding_error())?; + if !caps.iter().any(|cap| cap == FULL_MAINTENANCE_CAPABILITY) { + return Err(binding_error()); + } + let version: Option = sqlx::query_scalar( + "SELECT reported_agent_version FROM agent_installations WHERE tenant_id=$1 AND agent_id=$2 AND asset_id=$3 AND revoked_at IS NULL", + ) + .bind(job.tenant_id) + .bind(job.agent_id) + .bind(job.asset_id) + .fetch_optional(&mut **tx) + .await? + .flatten(); + let (_, manifest) = crate::agent_updates::checked_release(tx, release) + .await + .map_err(|err| { + if err.0.is_server_error() { + err + } else { + binding_error() + } + })?; + check_pair(&manifest, version.as_deref(), &job.execution_identity, caps)?; + if direct { + return Ok(true); + } + let current_policy = single_value(caps, "helper.policy.sha256:")?; + for anchor in policy + .release_anchors + .iter() + .filter(|a| a.agent_id == job.agent_id) + { + if anchor.policy_for(&manifest).as_deref() != Some(current_policy) { + continue; + } + let original = rmm_domain::jobs::hash(anchor.policy_json.as_bytes()); + let mut pinned = caps.to_owned(); + pinned.retain(|c| { + !c.starts_with("helper.binary.sha256:") && !c.starts_with("helper.policy.sha256:") + }); + pinned.push(format!("helper.binary.sha256:{}", anchor.helper_sha256)); + pinned.push(format!("helper.policy.sha256:{original}")); + if policy.permits(principal, job, &pinned) { + return Ok(true); + } + } + } + Err(Error(StatusCode::FORBIDDEN, "SCRIPT_HELPER_SCOPE_DENIED")) +} + +#[cfg(test)] +mod tests { + use super::*; + use rmm_domain::agent_update::ArtifactDescriptor; + + #[test] + fn signed_helper_is_bound_to_platform_reported_version_and_unambiguous_local_pins() { + let binary = "ab".repeat(32); + let policy = "cd".repeat(32); + let artifact = |role, sha256| ArtifactDescriptor { + role, + sha256, + artifact_id: Uuid::new_v4(), + bytes: 4096, + }; + let m = ReleaseManifest { + schema_version: 1, + release_id: Uuid::new_v4(), + release_sequence: 7, + version: "0.1.12".into(), + platform: Platform::WindowsGnuX64, + published_at: 10, + expires_at: 500, + protocol_major: 1, + state_schema: 1, + minimum_updater_version: 2, + artifacts: [ + artifact(ArtifactRole::Agent, "ef".repeat(32)), + artifact(ArtifactRole::Helper, binary.clone()), + ], + }; + // Rollover may substitute signed image pins and their release directory only. + let previous = Uuid::new_v4(); + let original_agent = "12".repeat(32); + let original_helper = "34".repeat(32); + let windows = |release: Uuid, agent: &str, helper: &str, runtime: u32| { + format!( + r#"{{"agent":{{"binary":"C:\\releases\\{release}\\agent.exe","binary_sha256":"{agent}"}},"helper":{{"binary":"C:\\releases\\{release}\\helper.exe","binary_sha256":"{helper}"}},"max_runtime_seconds":{runtime}}}"# + ) + }; + let mut anchor = ReleaseAnchor { + agent_id: Uuid::new_v4(), + release_id: previous, + policy_json: windows(previous, &original_agent, &original_helper, 30), + agent_sha256: original_agent, + helper_sha256: original_helper, + }; + let next_agent = &m.artifacts[0].sha256; + let expected = |limit| { + rmm_domain::jobs::hash(windows(m.release_id, next_agent, &binary, limit).as_bytes()) + }; + assert_eq!(anchor.policy_for(&m), Some(expected(30))); + assert_ne!(anchor.policy_for(&m), Some(expected(120))); + anchor + .policy_json + .push_str(&format!(r#","binary_sha256":"{}""#, anchor.helper_sha256)); + assert!(anchor.policy_for(&m).is_none()); + let mut caps = vec![ + format!("helper.binary.sha256:{binary}"), + format!("helper.policy.sha256:{policy}"), + ]; + assert!(check_pair(&m, Some("0.1.12"), "system", &caps).is_ok()); + assert!(check_pair(&m, Some("0.1.11"), "system", &caps).is_err()); + assert!(check_pair(&m, Some("0.1.12"), "root", &caps).is_err()); + caps.push(format!("helper.binary.sha256:{binary}")); + assert!(check_pair(&m, Some("0.1.12"), "system", &caps).is_err()); + caps.remove(0); + caps[1] = format!("helper.binary.sha256:{policy}"); + assert!(check_pair(&m, Some("0.1.12"), "system", &caps).is_err()); + } } diff --git a/crates/server/src/mcp.rs b/crates/server/src/mcp.rs index 06c86fa..9c38a39 100644 --- a/crates/server/src/mcp.rs +++ b/crates/server/src/mcp.rs @@ -58,6 +58,7 @@ struct Device { #[serde(deny_unknown_fields)] struct Plan { tenant_id: Uuid, + #[schemars(with = "crate::jobs::WebPlanInput")] input: crate::jobs::PlanRequest, } #[derive(Deserialize, schemars::JsonSchema)] @@ -138,11 +139,11 @@ fn tools() -> Vec { ), tool::( "logs.query", - "Read stored bounded log evidence, or request a live query as a pending approval operation.", + "Read stored bounded log evidence. Use a script job for a fresh collection.", ), tool::( "operations.plan", - "Persist immutable exact job plan. No executable jobs are created.", + "Plan a run_script operation for selected devices. The stored script and target list require interactive approval.", ), tool::( "operations.submit", @@ -156,10 +157,6 @@ fn tools() -> Vec { "jobs.cancel", "Request cancellation, not rollback or proof of termination.", ), - tool::( - "sessions.request", - "Unsupported until after MVP; never opens a shell.", - ), ] } fn parse(v: Value) -> Result { @@ -400,3 +397,37 @@ pub fn routes(r: Router, state: crate::State) -> Router, pub until: DateTime, pub max_lines: u32, + #[serde(default)] + #[schemars(skip)] pub live: bool, + #[schemars(skip)] pub idempotency_key: Option, } /// Both result endpoints use the reader's current token scope and tenant membership. @@ -83,89 +86,10 @@ pub async fn query( )); } if i.live { - let request_hash = rmm_domain::jobs::hash(&serde_json::to_vec(&i)?); - let mut dedup = rmm_persistence::tenant_tx(&s.pool, i.tenant_id).await?; - let key = i - .idempotency_key - .as_ref() - .filter(|k| !k.is_empty() && k.len() <= 128) - .ok_or(crate::jobs::Error( - StatusCode::BAD_REQUEST, - "VALIDATION_ERROR", - ))?; - if let Some(row)=sqlx::query("SELECT request_hash,plan_id FROM live_query_requests WHERE principal=$1 AND idempotency_key=$2").bind(&p.name).bind(key).fetch_optional(&mut *dedup).await?{ - if row.get::("request_hash")!=request_hash{return Err(crate::jobs::Error(StatusCode::CONFLICT,"IDEMPOTENCY_CONFLICT"))} - let plan=row.get("plan_id");let key=key.clone();dedup.commit().await?; - return crate::jobs::submit(s,p,i.tenant_id,plan,crate::jobs::Submit{idempotency_key:key}).await; - } - dedup.commit().await?; - let key = i.idempotency_key.ok_or(crate::jobs::Error( - StatusCode::BAD_REQUEST, - "VALIDATION_ERROR", - ))?; - let plan = crate::jobs::plan( - s, - p, - i.tenant_id, - crate::jobs::PlanInput { - targets: crate::jobs::Targets { - asset_ids: vec![i.asset_id], - }, - action, - script_variants: vec![], - execution_identity: "agent_service".into(), - schedule: crate::jobs::Schedule { - not_before: Utc::now(), - start_before: Utc::now() + chrono::Duration::hours(1), - }, - max_runtime_seconds: 30, - max_output_bytes: 262144, - rollout: crate::jobs::Rollout { - max_parallel: 1, - halt_after_failures: 1, - }, - reason: format!("Requested live logs for {}", i.unit), - artifact_ids: vec![], - }, - ) - .await?; - let id = plan["plan_id"] - .as_str() - .and_then(|v| Uuid::parse_str(v).ok()) - .ok_or(crate::jobs::Error( - StatusCode::INTERNAL_SERVER_ERROR, - "VALIDATION_ERROR", - ))?; - let mut dedup = rmm_persistence::tenant_tx(&s.pool, i.tenant_id).await?; - sqlx::query( - "INSERT INTO live_query_requests VALUES($1,$2,$3,$4,$5) ON CONFLICT DO NOTHING", - ) - .bind(i.tenant_id) - .bind(&p.name) - .bind(&key) - .bind(&request_hash) - .bind(id) - .execute(&mut *dedup) - .await?; - let canonical=sqlx::query("SELECT request_hash,plan_id FROM live_query_requests WHERE principal=$1 AND idempotency_key=$2").bind(&p.name).bind(&key).fetch_one(&mut *dedup).await?; - if canonical.get::("request_hash") != request_hash { - return Err(crate::jobs::Error( - StatusCode::CONFLICT, - "IDEMPOTENCY_CONFLICT", - )); - } - let id = canonical.get("plan_id"); - dedup.commit().await?; - return crate::jobs::submit( - s, - p, - i.tenant_id, - id, - crate::jobs::Submit { - idempotency_key: key, - }, - ) - .await; + return Err(crate::jobs::Error( + StatusCode::CONFLICT, + "SCRIPT_ACTION_REQUIRED", + )); } let mut tx = rmm_persistence::tenant_tx(&s.pool, i.tenant_id).await?; let access = LogReadAccess::for_principal(&mut tx, p).await?; diff --git a/crates/server/src/root_policy.rs b/crates/server/src/root_policy.rs index 4e616c6..4b1bfb9 100644 --- a/crates/server/src/root_policy.rs +++ b/crates/server/src/root_policy.rs @@ -377,7 +377,7 @@ pub async fn authorize( } let caps:serde_json::Value=sqlx::query_scalar("SELECT capabilities FROM agent_installations WHERE agent_id=$1 AND asset_id=$2 AND revoked_at IS NULL AND enrollment_generation=$3 AND assignment_version=$4").bind(job.agent_id).bind(job.asset_id).bind(i64::try_from(job.enrollment_generation).map_err(|_|Error(StatusCode::CONFLICT,"BINDING_MISMATCH"))?).bind(i64::try_from(job.assignment_version).map_err(|_|Error(StatusCode::CONFLICT,"BINDING_MISMATCH"))?).fetch_optional(&mut **tx).await?.ok_or(Error(StatusCode::CONFLICT,"AUTHORIZATION_REVOKED"))?; let caps: Vec = serde_json::from_value(caps)?; - if crate::managed_scripts::permits(principal, job, &caps)? { + if crate::managed_scripts::permits(tx, principal, job, &caps).await? { return Ok(()); } let policy = load()?; diff --git a/crates/server/src/script_library.rs b/crates/server/src/script_library.rs index ace39e7..645fb15 100644 --- a/crates/server/src/script_library.rs +++ b/crates/server/src/script_library.rs @@ -186,7 +186,7 @@ pub async fn plan( reason: input.reason, artifact_ids: vec![], }; - jobs::plan_resolved(s, p, tenant, plan, None, Some(reference)).await + jobs::plan_resolved(s, p, tenant, plan, Some(reference)).await } pub(crate) fn validate_plan_bindings(plan: &rmm_domain::jobs::PlanPayload) -> Result<(), Error> { @@ -263,7 +263,20 @@ pub(crate) mod tests { let tenant = p.tenant; let initial = list(s, p, tenant, PageQuery::default()).await.unwrap(); let items = initial["items"].as_array().unwrap(); - assert_eq!(items.len(), 13); + assert_eq!(items.len(), 15); + for (name, interpreter, identity) in [ + ("Linux neu starten", "posix_sh", "root"), + ("Windows neu starten", "powershell", "system"), + ] { + let revision = items.iter().find(|r| r["name"] == name).unwrap(); + assert_eq!(revision["version"], 1); + assert_eq!(revision["interpreter"], interpreter); + assert_eq!(revision["execution_identity"], identity); + assert_eq!( + revision["script_sha256"], + hash(revision["script_utf8"].as_str().unwrap().as_bytes()) + ); + } let template = items .iter() .find(|item| item["name"] == "Windows-Updates installieren") diff --git a/crates/server/src/windows_msi_catalog.rs b/crates/server/src/windows_msi_catalog.rs index 1f294cb..01f9326 100644 --- a/crates/server/src/windows_msi_catalog.rs +++ b/crates/server/src/windows_msi_catalog.rs @@ -72,7 +72,8 @@ pub async fn references( checked(tx, m).await?; Ok(vec![reference(m)]) } -pub async fn automatic_artifacts( +#[cfg(test)] +pub(crate) async fn automatic_artifacts( tx: &mut Transaction<'_, Postgres>, tenant: Uuid, action: &Action, diff --git a/crates/server/src/windows_policy.rs b/crates/server/src/windows_policy.rs index 6f4879c..c526138 100644 --- a/crates/server/src/windows_policy.rs +++ b/crates/server/src/windows_policy.rs @@ -38,6 +38,8 @@ pub(crate) struct SystemScope { acceptance_evidence_id: Uuid, allowed_services: Vec, #[serde(default, deserialize_with = "strict_optional_hashes")] + allowed_script_sha256: Option>, + #[serde(default, deserialize_with = "strict_optional_hashes")] allowed_msi_recipe_sha256: Option>, max_runtime_seconds: u32, #[serde( @@ -97,6 +99,15 @@ impl SystemScope { .collect::>() .len() == self.principals.len() + && self.allowed_script_sha256.as_ref().is_none_or(|hashes| { + hashes.len() <= 64 + && hashes.iter().all(|h| digest(h)) + && hashes + .iter() + .collect::>() + .len() + == hashes.len() + }) && self.allowed_services.len() <= 16 && self .allowed_services @@ -178,8 +189,16 @@ impl SystemScope { && has("system:set_service_state") && has("set_service_state") } - Action::RunScript { .. } => { + Action::RunScript { + script_utf8, + arguments, + .. + } => { allow_scripts + && self.allowed_script_sha256.as_ref().is_none_or(|hashes| { + arguments.is_empty() + && hashes.contains(&rmm_domain::jobs::hash(script_utf8.as_bytes())) + }) && job.action.full_maintenance() && (self.allowed_script_profiles.as_ref().is_some_and(|v| { v.contains( @@ -376,7 +395,7 @@ pub async fn authorize( } let caps:serde_json::Value=sqlx::query_scalar("SELECT capabilities FROM agent_installations WHERE tenant_id=$1 AND agent_id=$2 AND asset_id=$3 AND revoked_at IS NULL AND enrollment_generation=$4 AND assignment_version=$5").bind(job.tenant_id).bind(job.agent_id).bind(job.asset_id).bind(i64::try_from(job.enrollment_generation).map_err(|_|Error(StatusCode::CONFLICT,"BINDING_MISMATCH"))?).bind(i64::try_from(job.assignment_version).map_err(|_|Error(StatusCode::CONFLICT,"BINDING_MISMATCH"))?).fetch_optional(&mut **tx).await?.ok_or(Error(StatusCode::CONFLICT,"AUTHORIZATION_REVOKED"))?; let capabilities: Vec = serde_json::from_value(caps)?; - if crate::managed_scripts::permits(principal, job, &capabilities)? { + if crate::managed_scripts::permits(tx, principal, job, &capabilities).await? { return Ok(()); } let policy = load()?; @@ -569,6 +588,27 @@ mod tests { policy.schema_version = 3; assert!(policy.permits("selected", &job, &caps, Utc::now())); assert!(!policy.permits("foreign", &job, &caps, Utc::now())); + policy.scopes[0].allowed_script_sha256 = Some(vec![]); + assert!(!policy.permits("selected", &job, &caps, Utc::now())); + policy.scopes[0].allowed_script_sha256 = + Some(vec![rmm_domain::jobs::hash(b"Write-Output 'hi'\r\n")]); + assert!(policy.permits("selected", &job, &caps, Utc::now())); + let mut changed = job.clone(); + if let Action::RunScript { arguments, .. } = &mut changed.action { + arguments.push("unexpected".into()); + } + assert!(!policy.permits("selected", &changed, &caps, Utc::now())); + if let Action::RunScript { + arguments, + script_utf8, + .. + } = &mut changed.action + { + arguments.clear(); + script_utf8.push(' '); + } + assert!(!policy.permits("selected", &changed, &caps, Utc::now())); + policy.scopes[0].allowed_script_sha256 = None; let general = job.action.clone(); job.action = Action::RunScript { interpreter: "powershell".into(), @@ -600,13 +640,25 @@ mod tests { } #[test] fn windows_update_window_accepts_only_the_two_fixed_scripts() { - use rmm_domain::jobs::{PrivilegedScriptProfile, WindowsExecutionProfile, WINDOWS_UPDATE_IDENTITY_PROBE, WINDOWS_UPDATE_LONG_CAPABILITY, WINDOWS_UPDATE_SCRIPT_UTF8}; + use rmm_domain::jobs::{ + PrivilegedScriptProfile, WINDOWS_UPDATE_IDENTITY_PROBE, WINDOWS_UPDATE_LONG_CAPABILITY, + WINDOWS_UPDATE_SCRIPT_UTF8, WindowsExecutionProfile, + }; let (mut policy, mut job, mut caps) = fixture(); policy.schema_version = 3; let scope = &mut policy.scopes[0]; scope.allowed_services.clear(); scope.windows_update_max_runtime_seconds = Some(3600); - caps.extend(["run_script", "system:run_script", "script.powershell/1", "script.powershell.process_remote_signed/1", WINDOWS_UPDATE_LONG_CAPABILITY].map(str::to_owned)); + caps.extend( + [ + "run_script", + "system:run_script", + "script.powershell/1", + "script.powershell.process_remote_signed/1", + WINDOWS_UPDATE_LONG_CAPABILITY, + ] + .map(str::to_owned), + ); for (script, seconds, expected) in [ (WINDOWS_UPDATE_SCRIPT_UTF8, 3600, true), (WINDOWS_UPDATE_IDENTITY_PROBE, 30, true), @@ -614,13 +666,18 @@ mod tests { ("Write-Output 12", 30, false), ] { job.action = Action::RunScript { - interpreter:"powershell".into(), script_utf8:script.into(), - arguments:vec![], expected_stdout:None, - windows_execution_profile:Some(WindowsExecutionProfile::PowerShell51RemoteSigned), - privileged_script_profile:Some(PrivilegedScriptProfile::FullMaintenanceV1), + interpreter: "powershell".into(), + script_utf8: script.into(), + arguments: vec![], + expected_stdout: None, + windows_execution_profile: Some(WindowsExecutionProfile::PowerShell51RemoteSigned), + privileged_script_profile: Some(PrivilegedScriptProfile::FullMaintenanceV1), }; job.max_runtime_seconds = seconds; - assert_eq!(policy.permits("selected", &job, &caps, Utc::now()), expected); + assert_eq!( + policy.permits("selected", &job, &caps, Utc::now()), + expected + ); } } #[test] diff --git a/docs/mvp-completion-plan.md b/docs/mvp-completion-plan.md index 6d94387..350508e 100644 --- a/docs/mvp-completion-plan.md +++ b/docs/mvp-completion-plan.md @@ -6,14 +6,12 @@ **Freigabe für den Betrieb mit Administratorjobs und Neustarts ausstehend.** In Development A waren Linux `0.1.0-mvp.4` und Windows GNU `0.1.11` online. Die öffentliche WebUI zeigte für beide Dienstkonto-Aufträge und beide Administratorproben Exitcode 0. Linux meldete die effektiven UIDs 990 und 0. Windows meldete die SIDs von LocalService und LocalSystem. LocalSystem war an eine feste Bibliotheksrevision im temporären Wartungsfenster gebunden. Der Probeauftrag mit frei formuliertem SYSTEM-Skript wurde bereits bei der Planung abgewiesen. Nach dem regulären Rückbau lief ein weiterer Windows-Dienstauftrag im selben Boot erfolgreich. Die Entscheidungen erfolgten durch den gekennzeichneten Testprincipal. Ein auf Development A begrenzter MCP-Lesetoken sah die beiden Geräte, wurde beim Zugriff auf B abgewiesen und verlor nach Widerruf den Zugang. [Gesamtprüfung](evidence/mvp-whole-review-20261118.json) -| Offener Punkt | Befund am ausgelieferten Stand | Nächster Nachweis | -| --- | --- | --- | -| Neustart als eigener Job | Der WebUI-Assistent sperrte auf beiden VMs die Einreichung. Die öffentliche Policy für verwaltete Skripte deckt nur Skripte ab. Der separate Serverpfad für Neustarts setzt eine Entwicklungsrichtlinie voraus. | Einen auf Kunde, Kopplung und Aktion begrenzten Neustart über die reguläre Produktionsplanung und WebUI-Genehmigung nachweisen. | -| Linux | Der aktuelle Helper ist an das Profil für Root-Skripte gebunden. Der General-Helper des früheren Neustarttests nutzt eine andere Identität und ein anderes Journal. | Zur aktiven Installation passenden Neustart-Helper sowie die zugehörigen Sperren und den dauerhaften Ausführungsbeleg provisionieren. [Linux-Abnahme](evidence/mvp-linux-service-admin-reboot-20261118.json) | -| Windows | Für die öffentliche Vollwartungsrichtlinie fehlt die neue Kopplung. Auch während des Windows-Wartungsfensters fehlte die Neustartfähigkeit. Im ausgelieferten GNU-Build akzeptiert die Standardinstallation für SYSTEM nur die vorgesehenen Wartungsskripte und die Identitätsprobe. | Einrichtung und Fortschreibung des Helperbezugs prüfen, den typisierten Neustart im Standardagenten anbinden und beide Fähigkeiten auf der aktuellen Geräteidentität nachweisen. [Ausführungsprüfung im Agenten](../crates/agent-windows/src/runtime.rs#L1412) · [Windows-Abnahme](evidence/mvp-windows-service-admin-reboot-20261118.json) | -| Einheitlicher Linux-Verteilstand | Der signierte Kundenkatalog von Development B bietet Linux `0.1.0-mvp.2`, der von A `0.1.0-mvp.4`. Windows bietet in beiden Kunden `0.1.11`. | Den aktuellen Linux-Release samt passendem Starter-Worker in B veröffentlichen und per HTTPS-Bootstrap nachlesen. | +| Auftrag | Abnahmekriterium für Version 1.39 | +| --- | --- | +| WebUI und MCP | Neue Aufträge verwenden `run_script`. Die WebUI zeigt die konkrete Skriptrevision, die Ausführungsrechte und das Ergebnis. Historische typisierte Aufträge bleiben lesbar. | +| Linux-Test-VM | Bestehende Kopplung behalten. Ein Root-Bibliotheksskript plant den Neustart. Ein neuer Boot und ein Folgeauftrag unter dem Dienstkonto müssen nachgewiesen werden. | +| Windows-Test-VM | Eingerichteten SYSTEM-Helper an das signierte GNU-Paar binden. Eine eigene Identitätsabfrage, ein Neustart-Bibliotheksskript und ein Folgeauftrag müssen über den normalen Genehmigungsweg gelingen. | -**Abschlusskriterium:** Je VM genau einen typisierten Neustartjob einreichen und genehmigen. Den einmaligen Start, die neue Boot-ID, denselben authentisierten Agenten und frischen Kontakt festhalten. Anschließend pro VM einen neuen Dienstkonto-Auftrag einreichen und dessen Ergebnis in der WebUI prüfen. In dieser Abnahme kam auf keinem Ziel ein Neustartplan zustande. ## Ergänzte Lieferungen am 17. November 2026 diff --git a/docs/project-decisions.md b/docs/project-decisions.md index dc748c8..7596ab3 100644 --- a/docs/project-decisions.md +++ b/docs/project-decisions.md @@ -1,6 +1,10 @@ # Verbindliche Projektentscheidungen -Stand: **2026-11-17**, Spezifikation **1.37** (`Rust_RMM_Implementierungsspezifikation.md`). Die ausdrücklichen normativen Entscheidungen in Kapitel 0 haben Vorrang vor früheren Architekturannahmen. Version 1.6 ersetzt die lokale Servertopologie durch den dedizierten Internetserver; Version 1.7 präzisiert das Notebook als reinen Entwicklungsrechner; Version 1.8 erlaubt vorgezogene parallele Windows-Entwicklung. +Stand: **2026-11-18**, Spezifikation **1.39** (`Rust_RMM_Implementierungsspezifikation.md`). Die ausdrücklichen normativen Entscheidungen in Kapitel 0 haben Vorrang vor früheren Architekturannahmen. Version 1.6 ersetzt die lokale Servertopologie durch den dedizierten Internetserver; Version 1.7 präzisiert das Notebook als reinen Entwicklungsrechner; Version 1.8 erlaubt vorgezogene parallele Windows-Entwicklung. + +## Aktionen über Skripte (Version 1.39) + +Der Betreiber hat einen einzigen Ausführungsweg gewählt. Sowohl ein einmaliges Skript als auch eine Bibliotheksrevision durchlaufen denselben Genehmigungs- und Rückmeldeweg. Die Neustartvorlagen benutzen die Betriebssystemfunktion mit einer Minute Vorlauf für die Ergebnismeldung. Für die erfolgreiche Wiederkehr zählt der Bootwechsel mit anschließendem Auftrag. Die Geräteansicht unterscheidet das Dienstkonto vom verfügbaren Administrator-Kontext. Ein früher eingerichtetes enges Wartungsprofil behält seinen Umfang. Der dauerhafte Skripthelfer braucht eine ausdrückliche lokale Einrichtung sowie eine passende zentrale Geräte- und Rollenbindung. [Produktvertrag](../Rust_RMM_Implementierungsspezifikation.md#010-ausführbare-geräteaufträge-version-139) ## Offizieller Windows-x64-Release (Version 1.38, 18. November 2026) diff --git a/docs/public-access.md b/docs/public-access.md index 70e9761..25d6dfb 100644 --- a/docs/public-access.md +++ b/docs/public-access.md @@ -2,6 +2,12 @@ Die WebUI ist unter https://discovery.ease-technologies.de:8443/ erreichbar. Der MCP-Endpunkt lautet https://discovery.ease-technologies.de:8443/mcp. Beide verwenden die öffentliche TLS-Zertifikatskette des bestehenden HTTPS-Ingresses. Der Gerätekanal auf Port 443 verwendet weiterhin seine eigene Geräte-PKI. +## Neustart und Administratorausführung + +Unter **Aufträge → Neuer Auftrag** das Gerät wählen und **Neustartskript auswählen** verwenden. Bei gemischten Plattformen pro Betriebssystem einen Auftrag anlegen. Die Vorschau zeigt den vollständigen Inhalt und den Ausführungskontext. Nach der Entscheidung unter **Genehmigungen** steht die Ausgabe im Auftrag. „Neustart in einer Minute eingeplant“ bestätigt die Annahme durch das Betriebssystem. Der Wiederanlauf ist nach einem neuen Bootbezug, frischem Agentkontakt und erfolgreichem Folgeauftrag belegt. + +Die letzte Meldung im Gerätedetail zeigt, ob der Client Skripte mit dem Dienstkonto und mit Administratorrechten unterstützt. Die tatsächliche Freigabe für einen Nutzer hängt zusätzlich von Kunde, Gerät und den zentralen Ausführungsrechten ab. + ## WebUI Die Anmeldung benötigt den lokalen Benutzernamen, das Passwort und einen sechsstelligen TOTP-Code aus einer Authenticator-App. TOTP verwendet SHA-1, 30 Sekunden und sechs Stellen. Für die Ersteinrichtung liegt auf dem Entwicklungs-PC die private Datei `credentials/public-webui-login.json` mit Benutzername, Passwort, Base32-Schlüssel und `otpauth_uri`. Die Datei hat Modus 0600 und ist gitignoriert. Sie dient der Übernahme des Passworts in den Passwortmanager und der Einrichtung der Authenticator-App. diff --git a/migrations/0038_restart_scripts.sql b/migrations/0038_restart_scripts.sql new file mode 100644 index 0000000..1673511 --- /dev/null +++ b/migrations/0038_restart_scripts.sql @@ -0,0 +1,44 @@ +-- The approved operation schedules a reboot through the OS and can return +-- its script output before services stop. Fresh inventory proves the new boot. +CREATE FUNCTION seed_restart_scripts(target_tenant uuid) RETURNS void +LANGUAGE plpgsql SET search_path = pg_catalog, public AS $seed$ +DECLARE previous_tenant text := coalesce(current_setting('app.tenant_id', true), ''); +BEGIN + PERFORM set_config('app.tenant_id', target_tenant::text, true); + INSERT INTO public.script_revisions(tenant_id, name, version, interpreter, execution_identity, created_by, script_utf8) + VALUES + (target_tenant,'Linux neu starten',1,'posix_sh','root','system:bootstrap',$sh$#!/bin/sh +set -eu +/usr/sbin/shutdown -r +1 'Genehmigter Neustart durch die Geräteverwaltung' +printf '%s\n' 'Neustart in einer Minute eingeplant.' +$sh$), + (target_tenant,'Windows neu starten',1,'powershell','system','system:bootstrap',$ps$$ErrorActionPreference = 'Stop' +& "$env:SystemRoot\System32\shutdown.exe" /r /t 60 /d p:0:0 /c 'Genehmigter Neustart durch die Geraeteverwaltung' +if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE } +Write-Output 'Neustart in einer Minute eingeplant.' +$ps$) + ON CONFLICT (tenant_id, name, version) DO NOTHING; + PERFORM set_config('app.tenant_id', previous_tenant, true); +END +$seed$; +REVOKE ALL ON FUNCTION seed_restart_scripts(uuid) FROM PUBLIC; + +CREATE OR REPLACE FUNCTION seed_tenant_script_library() RETURNS trigger +LANGUAGE plpgsql SECURITY DEFINER SET search_path = pg_catalog, public AS $$ +DECLARE previous_tenant text := coalesce(current_setting('app.tenant_id', true), ''); +BEGIN + PERFORM set_config('app.tenant_id', NEW.tenant_id::text, true); + PERFORM public.seed_windows_update_script(NEW.tenant_id); + PERFORM public.seed_standard_diagnostic_scripts(NEW.tenant_id); + PERFORM public.seed_restart_scripts(NEW.tenant_id); + PERFORM set_config('app.tenant_id', previous_tenant, true); + RETURN NEW; +END +$$; + +DO $backfill$ +BEGIN + LOCK TABLE tenants IN SHARE ROW EXCLUSIVE MODE; + PERFORM public.seed_restart_scripts(tenant_id) FROM tenants; +END +$backfill$; diff --git a/tests/browser/customer-management.spec.ts b/tests/browser/customer-management.spec.ts index feae178..3f22a8c 100644 --- a/tests/browser/customer-management.spec.ts +++ b/tests/browser/customer-management.spec.ts @@ -138,7 +138,9 @@ test('removes the confirmed historical installation and keeps its successor', as await page.route(origin + '/api/v1/**', async r => { const req = r.request(), url = new URL(req.url()); const historical = { ...device, agent_id: old, lifecycle: revoked ? 'revoked' : 'replaced', status: 'offline' }; - const successor = { ...device, agent_id: active, lifecycle: 'current', status: 'online' }; + const successor = { ...device, agent_id: active, lifecycle: 'current', status: 'online', source_id: 'windows.base', + capabilities: ['windows.base/1', 'rmm.sync.v1', 'run_script', 'script.powershell/1', 'script.powershell.process_remote_signed/1', + 'script.full_maintenance/1', 'helper.system.v1', 'system:run_script'] }; if (url.pathname === '/api/v1/tenants') return r.fulfill({ json: listing([customer]) }); if (url.pathname === '/api/v1/devices' || url.pathname === path.slice(0, path.lastIndexOf('/'))) { return r.fulfill({ json: listing(url.searchParams.get('view') === 'history' ? (deleted ? [] : [historical]) : [successor]) }); @@ -191,6 +193,7 @@ test('removes the confirmed historical installation and keeps its successor', as await page.getByRole('button', { name: 'Bestand' }).click(); await page.getByRole('button', { name: 'NORD-PC' }).click(); await expect(page).toHaveURL(new RegExp(active + '$')); + await expect(page.getByText('PowerShell als Dienstkonto und als Administrator (SYSTEM)')).toBeVisible(); await page.getByText('Gerät verwalten', { exact: true }).click(); await expect(page.getByRole('button', { name: 'Kopplung löschen' })).toHaveCount(0); await expect(page.getByText('Geräteidentität widerrufen', { exact: true })).toBeVisible(); diff --git a/tests/browser/management-read.spec.ts b/tests/browser/management-read.spec.ts index 82c507c..56d438b 100644 --- a/tests/browser/management-read.spec.ts +++ b/tests/browser/management-read.spec.ts @@ -15,11 +15,10 @@ test('real dev browser membership/catalog read and administrative controls stay await test.step('management:membership-heading', async () => { await expect(page.getByRole('heading', { name: 'Mitgliedschaft und Ausführungsstopp' })).toBeVisible(); }); await test.step('management:stop-status', async () => { await expect(page.getByRole('status', { name: 'Ausführungsstatus' })).toHaveText(/Neue Starts sind (freigegeben|gestoppt)/); }); await page.getByRole('link', {name:'Erweitert',exact:true}).click(); - await page.getByRole('link', { name: 'Wartungsauftrag planen', exact: true }).click(); - await test.step('management:action-option', async () => { await expect(page.getByLabel('Aktion', { exact: true }).locator('option[value="apt_native_acceptance"]')).toHaveCount(1); }); - await test.step('management:select-native', async () => { await page.getByLabel('Aktion', { exact: true }).selectOption('apt_native_acceptance'); }); - await test.step('management:native-hint', async () => { await expect(page.getByText('NUR SIMULIERTE DEV/TEST-NATIVABNAHME.', { exact: false })).toBeVisible(); }); - await test.step('management:identity-unchanged', async () => { await expect(page.getByLabel('Ausführungsidentität', { exact: true })).toHaveValue('agent_service'); }); + await expect(page.getByRole('link', { name: 'Wartungsauftrag planen' })).toHaveCount(0); + await page.getByRole('link', { name: 'Aufträge', exact: true }).click(); + await page.getByRole('link', { name: 'Neuer Auftrag', exact: true }).click(); + await expect(page.getByRole('heading', { name: 'Geräte auswählen' })).toBeVisible(); await test.step('management:inert-controls', async () => { expect(mutations).toBe(0); }); await test.step('management:logout', async () => { await page.getByRole('button', { name: 'Abmelden', exact: true }).click(); await expect(page.getByRole('button', { name: 'Anmelden', exact: true })).toBeVisible(); }); }); diff --git a/tests/browser/mvp-actions.spec.ts b/tests/browser/mvp-actions.spec.ts index db4f703..a4575ec 100644 --- a/tests/browser/mvp-actions.spec.ts +++ b/tests/browser/mvp-actions.spec.ts @@ -26,7 +26,7 @@ test('simulated human prepares root request through UI only, without approving', const request = object(expected.request), params = object(request.parameters); expect(params.execution_identity).toBe('root'); expect(object(request.targets).asset_ids).toEqual([expected.asset_id]); - expect(['run_script', 'query_logs', 'set_service_state', 'apt_native_acceptance', 'ensure_package', 'apply_updates', 'reboot']).toContain(request.action); + if (request.action !== 'run_script') throw new Error('Retired device action. Supply a run_script request for this preparation.'); let authorizationRequests = 0; page.on('request', r => { if (new URL(r.url()).pathname.endsWith('/authorizations')) authorizationRequests++; }); const sessionResponse = page.waitForResponse(r => new URL(r.url()).pathname === '/auth/session' && r.status() === 200); @@ -38,39 +38,30 @@ test('simulated human prepares root request through UI only, without approving', await page.getByRole('checkbox', { name: `Ziel ${text(expected.asset_id)}`, exact: true }).check(); await page.getByRole('link', { name: 'Aufträge', exact: true }).click(); await page.getByRole('link', { name: 'Neuer Auftrag', exact: true }).click(); - await page.getByRole('link', { name: 'Verwaltung', exact: true }).click(); - await page.getByRole('link', { name: 'Erweitert', exact: true }).click(); - await page.getByRole('link', { name: 'Wartungsauftrag planen', exact: true }).click(); - await page.getByLabel('Aktion', { exact: true }).selectOption(text(request.action)); - if (request.action === 'run_script') { - const variants = params.variants; - if (!Array.isArray(variants) || variants.length !== 1) throw new Error('One exact script variant required'); - const variant = object(variants[0]); - await page.getByRole('combobox', { name: 'Interpreter', exact: true }).selectOption(text(variant.interpreter)); - await page.getByLabel('Exakte UTF-8 Skriptbytes', { exact: false }).fill(text(variant.script_utf8)); - await page.getByLabel('Erwartete stdout-Ausgabe', { exact: false }).fill(text(params.expected_stdout)); - } else { - await page.getByLabel('Aktionsparameter', { exact: true }).fill(JSON.stringify(params)); - } - await page.getByLabel('Ausführungsidentität', { exact: true }).selectOption('root'); - await page.getByLabel('Laufzeitlimit (s)', { exact: true }).fill(String(params.timeout_seconds)); - await page.getByLabel('Ausgabelimit (Bytes)', { exact: true }).fill(String(params.max_output_bytes)); - // Runner fixes browser/Node TZ to UTC. The actual UI's minute-precision form - // selects an explicit future minute; all resulting exact bytes are reviewed - // again in the separate approval test before any executable job can exist. + await page.getByRole('button', { name: 'Weiter zum Skript', exact: true }).click(); + await page.getByRole('radio', { name: 'Einmaliges Skript' }).check(); + const variants = params.variants; + if (!Array.isArray(variants) || variants.length !== 1) throw new Error('One exact script variant required'); + const variant = object(variants[0]); + await page.getByLabel('Plattform und Interpreter').selectOption(text(variant.interpreter)); + await page.getByLabel('Skriptinhalt', { exact: true }).fill(text(variant.script_utf8)); + await page.getByLabel('Ausführen als', { exact: true }).selectOption('root'); + await page.getByText('Zeitfenster und Ausführungsoptionen', { exact: true }).click(); + await page.getByLabel('Erwartete Standardausgabe (optional)').fill(params.expected_stdout == null ? '' : text(params.expected_stdout)); + await page.getByLabel('Laufzeit je Gerät in Sekunden').fill(String(params.timeout_seconds)); + await page.getByLabel('Ausgabelimit in Byte').fill(String(params.max_output_bytes)); const start = new Date(Math.ceil(Date.now() / 60000) * 60000); - await page.getByLabel('Frühester Start (lokale Zeit)', { exact: true }).fill(start.toISOString().slice(0, 16)); - await page.getByLabel('Startfrist / Ablauf (lokale Zeit)', { exact: true }).fill(new Date(start.getTime() + 15 * 60000).toISOString().slice(0, 16)); - await page.getByLabel('Maximal parallel', { exact: true }).fill('1'); + await page.getByLabel('Frühester Start', { exact: true }).fill(start.toISOString().slice(0, 16)); + await page.getByLabel('Startfrist', { exact: true }).fill(new Date(start.getTime() + 15 * 60000).toISOString().slice(0, 16)); + await page.getByLabel('Geräte gleichzeitig').fill('1'); await page.getByLabel('Stopp nach Fehlern', { exact: true }).fill('1'); await page.getByLabel('Begründung', { exact: true }).fill(text(request.reason)); - await page.getByRole('button', { name: 'Plan erstellen · noch keine Ausführung' }).click(); - const detail = page.locator('section[data-plan-id]'); - await detail.getByText('Technische Plandaten', { exact: true }).click(); - await expect(detail.getByLabel('Technische Plandaten', { exact: true })).toBeVisible(); - const plan = object(JSON.parse(await detail.getByLabel('Technische Plandaten', { exact: true }).innerText())); + const prepared = page.waitForResponse(r => r.request().method() === 'POST' && new URL(r.url()).pathname.endsWith('/operation-plans') && r.ok()); + await page.getByRole('button', { name: 'Zusammenfassung ansehen' }).click(); + await expect(page.getByRole('heading', { name: 'Zusammenfassung' })).toBeVisible(); + const plan = object(await (await prepared).json()); expect(createHash('sha256').update(bytes(plan.plan_payload_bytes)).digest('hex')).toBe(plan.plan_hash); - await detail.getByRole('button', { name: 'Zur Genehmigung einreichen' }).click(); + await page.getByRole('button', { name: 'Zur Genehmigung einreichen' }).click(); const op = page.locator('section[data-operation-id]'); await op.getByText('Technische Auftragsdaten', { exact: true }).click(); await expect(op.getByLabel('Technische Auftragsdaten', { exact: true })).toContainText('"job_count": 0'); @@ -186,6 +177,11 @@ test('one opted-in immutable dev/test action: inspect all fixed bytes → UI cli const approve = detail.getByRole('button', { name: 'SIMULIERT: Genehmigen', exact: true }); await expect(approve).toBeDisabled(); await detail.getByRole('checkbox', { name: 'Ich habe die Geräte, den Inhalt und die Ausführungsrechte geprüft.', exact: false }).check(); + if (action.action !== 'run_script') { + await expect(approve).toBeDisabled(); + await expect(detail.getByRole('alert')).toContainText('frühere Aktionsart'); + return; + } await expect(approve).toBeEnabled(); await approve.click(); // Deliberately no API client, injected fetch, route or direct approval request. await op.getByText('Technische Auftragsdaten', { exact: true }).click(); diff --git a/tests/browser/order-composer.spec.ts b/tests/browser/order-composer.spec.ts index 438e8ce..95db2be 100644 --- a/tests/browser/order-composer.spec.ts +++ b/tests/browser/order-composer.spec.ts @@ -96,10 +96,14 @@ test('applies order filters from the first page and clears them on reset', async expect(requests.at(-1)?.searchParams.has('device')).toBe(false); }); -test('uses the execution stop status and blocks restart planning until the device reports support', async ({ page }) => { +test('shows the execution stop and prepares the Windows restart through a versioned administrator script', async ({ page }) => { const api = '/api/v1/tenants/' + tenantId; const permissions = [...auth.permissions, 'tenant:stop', 'system:execute']; - let stopped = false, ready = false; + let stopped = false, scopeDenied = false; + const restart = { + ...script, name: 'Windows neu starten', revision_id: randomUUID(), version: 2, + interpreter: 'powershell', execution_identity: 'system', script_utf8: "Write-Output 'Neustart-Test'\n" + }; const writes: unknown[] = []; await page.route(origin + '/auth/config', r => r.fulfill({ json: { dev_login_enabled: false, local_login_enabled: true, oidc_configured: false, oidc_login_url: null @@ -113,12 +117,16 @@ test('uses the execution stop status and blocks restart planning until the devic return r.fulfill({ json: { tenant_id: tenantId, changes_stopped: stopped } }); } if (pathname === api + '/devices') return r.fulfill({ json: listing([windows]) }); - if (pathname === api + '/devices/' + windows.asset_id) return r.fulfill({ json: { - ...windows, tenant_id: tenantId, - capabilities: ready ? ['reboot', 'rmm.sync.v1', 'windows.reboot/1', 'helper.system.v1', 'system:reboot'] : [] - } }); - if (req.method() !== 'GET') writes.push(req.postDataJSON()); - return r.fulfill({ status: 409, json: { code: 'UNSUPPORTED_CAPABILITY' } }); + if (pathname === api + '/script-revisions') return r.fulfill({ json: listing([ + { ...restart, script_sha256: hash(restart.script_utf8) } + ]) }); + if (req.method() !== 'GET') { + expect(req.headers()['x-csrf-token']).toBe(auth.csrf_token); + writes.push({ pathname, body: req.postDataJSON() }); + } + return scopeDenied + ? r.fulfill({ status: 403, json: { code: 'SCRIPT_HELPER_SCOPE_DENIED' } }) + : r.fulfill({ status: 409, json: { code: 'UNSUPPORTED_CAPABILITY' } }); }); await page.goto(origin + '/#verwaltung/rechte'); @@ -132,23 +140,96 @@ test('uses the execution stop status and blocks restart planning until the devic await expect(page.getByText('Mandantenausführung wieder zulassen', { exact: true })).toBeVisible(); expect(writes).toHaveLength(0); - await page.goto(origin + '/#auftraege/neu'); + await page.goto(origin + '/#auftraege/wartung'); await page.getByRole('checkbox', { name: /test-windows/ }).check(); - await page.getByRole('button', { name: 'Weiter zur Aktion' }).click(); - await page.getByRole('radio', { name: 'Gerät neu starten' }).check(); + await page.getByRole('button', { name: 'Weiter zum Skript' }).click(); + await page.getByRole('button', { name: 'Neustartskript auswählen' }).click(); + await expect(page.getByRole('combobox', { name: 'Bibliotheksskript', exact: true })).toHaveValue(restart.name); + await expect(page.getByRole('combobox', { name: 'Version', exact: true })).toHaveValue(restart.revision_id); + await expect(page.getByRole('combobox', { name: 'Ausführen als', exact: true })).toHaveValue('system'); + await page.getByText('Skriptinhalt anzeigen').click(); + await expect(page.locator('pre')).toHaveText(restart.script_utf8.trim()); await page.getByLabel('Begründung', { exact: true }).fill('Neustart prüfen'); - const plan = page.getByRole('button', { name: 'Zusammenfassung ansehen' }); - await expect(page.getByRole('alert')).toContainText('keine Neustartfähigkeit'); - await expect(plan).toBeDisabled(); expect(writes).toHaveLength(0); - ready = true; - await expect(plan).toBeEnabled({ timeout: 8000 }); - await plan.click(); - await expect(page.getByRole('alert')).toContainText('unterstützt die ausgewählte Ausführung noch nicht'); - expect(writes).toEqual([expect.objectContaining({ - action: 'reboot', targets: { asset_ids: [windows.asset_id] }, - parameters: expect.objectContaining({ execution_identity: 'system', reconnect_timeout_seconds: 180 }) - })]); + await page.getByRole('button', { name: 'Zusammenfassung ansehen' }).click(); + await expect(page.getByRole('alert')).toContainText('Skript-Helper für SYSTEM noch nicht als betriebsbereit gemeldet'); + expect(writes).toEqual([{ + pathname: api + '/script-revisions/' + restart.revision_id + '/plan', + body: expect.objectContaining({ + reason: 'Neustart prüfen', targets: { asset_ids: [windows.asset_id] }, max_runtime_seconds: 120, max_output_bytes: 65536 + }) + }]); + scopeDenied = true; + await page.getByRole('button', { name: 'Zusammenfassung ansehen' }).click(); + await expect(page.getByRole('alert')).toContainText('zentrale Richtlinie erlaubt dieses Administratorskript'); + expect(writes).toHaveLength(2); +}); + +test('offers local admin opt-in on both installer commands and keeps the one-time code outside commands', async ({ page }) => { + const token = 'f'.repeat(64), api = '/api/v1/tenants/' + tenantId; + const requests: string[] = []; + await page.route(origin + '/auth/config', r => r.fulfill({ json: { dev_login_enabled: true, oidc_configured: false, oidc_login_url: null } })); + await page.route(origin + '/auth/session', r => r.fulfill({ json: { ...auth, permissions: [...auth.permissions, 'devices:enroll'] } })); + await page.route(origin + '/api/v1/**', r => { + const req = r.request(), url = new URL(req.url()); + if (req.method() !== 'GET') requests.push(url.pathname); + if (url.pathname === '/api/v1/tenants') return r.fulfill({ json: listing(auth.tenants) }); + if (url.pathname === api + '/enrollment-tokens') return r.fulfill({ json: { + token, expires_at: new Date(Date.now() + 900000).toISOString(), bootstrap_origin: 'https://bootstrap.example', + release_platforms: ['x86_64-unknown-linux-gnu', 'x86_64-pc-windows-gnu'] + } }); + return r.fulfill({ json: { ...listing([]), pending_count: 0 } }); + }); + await page.goto(origin + '/#verwaltung/aufnahme'); + const enroll = page.getByRole('region', { name: 'Gerät aufnehmen' }); + const option = enroll.getByRole('checkbox', { name: /Administratorskripte/ }); + await expect(option).not.toBeChecked(); + await enroll.getByRole('button', { name: 'Einmalcode erstellen' }).click(); + const commands = enroll.locator('pre'); + await expect(commands).toHaveCount(2); + expect((await commands.allTextContents()).join(' ')).not.toMatch(/enable-admin-scripts|EnableAdministratorScripts/); + await option.check(); + await expect(commands.nth(0)).toContainText('--enable-admin-scripts'); + await expect(commands.nth(1)).toContainText('-EnableAdministratorScripts'); + await expect(enroll.getByText(/Für jeden Auftrag gelten zusätzlich/)).toBeVisible(); + expect((await commands.allTextContents()).join(' ')).not.toContain(token); + expect(requests).toEqual([api + '/enrollment-tokens']); +}); + +test('keeps an old pending device action readable and prevents approval', async ({ page }) => { + const golden = JSON.parse(readFileSync(resolve(__dirname, '../script_console/codec-golden.json'), 'utf8')); + const fixed = JSON.parse(Buffer.from(golden[0].plan_payload_bytes).toString('utf8')); + fixed.plan_id = randomUUID(); + fixed.tenant_id = tenantId; + const job = fixed.jobs[0]; + const end = new Date(Date.now() + 600000).toISOString(); + job.payload = { ...job.payload, tenant_id: tenantId, asset_id: linux.asset_id, agent_id: linux.agent_id, + action: { action: 'refresh_inventory', scope: 'linux.base' }, execution_identity: 'agent_service', start_before: end }; + delete job.script_sha256; + job.job_payload_hash = hash(JSON.stringify(job.payload)); + const bytes = JSON.stringify(fixed); + const plan = { plan_id: fixed.plan_id, plan_hash: hash(bytes), plan_payload_bytes: [...Buffer.from(bytes)], + plan_payload: fixed, jobs: fixed.jobs, targets: [linux], resolved_targets: [{ asset_id: linux.asset_id, agent_id: linux.agent_id }], + excluded_targets: [], expires_at: end, approval_state: 'pending_approval' }; + const writes: string[] = []; + await page.route(origin + '/auth/config', r => r.fulfill({ json: { + dev_login_enabled: true, oidc_configured: false, oidc_login_url: null + } })); + await page.route(origin + '/auth/session', r => r.fulfill({ json: { ...auth, permissions: [...auth.permissions, 'plans:approve'] } })); + await page.route(origin + '/api/v1/**', r => { + const url = new URL(r.request().url()); + if (r.request().method() !== 'GET') writes.push(url.pathname); + if (url.pathname.endsWith('/operation-plans/' + fixed.plan_id)) return r.fulfill({ json: plan }); + if (url.pathname === '/api/v1/tenants') return r.fulfill({ json: listing(auth.tenants) }); + return r.fulfill({ json: { ...listing([]), pending_count: 0 } }); + }); + await page.goto(origin + '/#genehmigungen/pruefen/' + tenantId + '/' + fixed.plan_id); + await expect(page.locator('.review-targets').getByText('test-linux', { exact: true })).toBeVisible(); + await expect(page.getByRole('alert')).toHaveText(/frühere Aktionsart/); + await page.getByRole('checkbox', { name: /Ich habe die Geräte/ }).check(); + await expect(page.getByRole('button', { name: 'SIMULIERT: Genehmigen' })).toBeDisabled(); + await expect(page.getByRole('button', { name: 'SIMULIERT: Ablehnen' })).toBeEnabled(); + expect(writes).toEqual([]); }); test('shows the bound script text alongside single and per-device results', async ({ page }) => { @@ -266,11 +347,17 @@ test('shows the bound script text alongside single and per-device results', asyn await expect(source.getByLabel('Gespeicherter Skripttext')).toHaveCount(0); }); -for (const library of [true, false]) { - test( - library - ? 'pins a revision, blocks an incompatible target and finds the submitted order after a lost response' - : 'submits a one-time script without publishing a library revision', +for (const scenario of ['library', 'once', 'restart'] as const) { + const library = scenario !== 'once'; + const restart = scenario === 'restart'; + const revision = restart ? { ...script, name: 'Linux neu starten', execution_identity: 'root', script_utf8: "printf 'Neustart-Test\n'\n" } : script; + const session = restart ? { ...auth, permissions: [...auth.permissions, 'root:execute'] } : auth; + const title = { + library: 'pins a revision, blocks an incompatible target and finds the submitted order after a lost response', + once: 'submits a one-time script without publishing a library revision', + restart: 'submits the versioned Linux restart through the ordinary script plan with root identity' + }[scenario]; + test(title, async ({ page }) => { let operationId: string | null = null; let plan: Record | null = null; @@ -283,7 +370,7 @@ for (const library of [true, false]) { import React from '/node_modules/.vite/deps/react.js'; import ReactDOM from '/node_modules/.vite/deps/react-dom_client.js'; import {OrderComposer} from '/src/order-composer.tsx'; - ReactDOM.createRoot(document.querySelector('#root')).render(React.createElement(OrderComposer,{tenantId:'${tenantId}',auth:${JSON.stringify(auth)},initialAssetIds:['${linux.asset_id}'],onSubmitted:id=>document.body.setAttribute('data-operation',id)})); + ReactDOM.createRoot(document.querySelector('#root')).render(React.createElement(OrderComposer,{tenantId:'${tenantId}',auth:${JSON.stringify(session)},initialAssetIds:['${linux.asset_id}'],onSubmitted:id=>document.body.setAttribute('data-operation',id)})); ` }) ); @@ -297,7 +384,7 @@ for (const library of [true, false]) { return r.fulfill({ json: suffix.endsWith(linux.asset_id) ? linux : windows }); if (suffix === '/script-revisions') return r.fulfill({ - json: listing([{ ...script, script_sha256: hash(script.script_utf8), version: issuedVersion }]) + json: listing([{ ...revision, script_sha256: hash(revision.script_utf8), version: issuedVersion }]) }); if (suffix === '/operation-plans/' + plan?.plan_id) return r.fulfill({ json: { ...plan, operation_id: operationId } }); @@ -305,16 +392,17 @@ for (const library of [true, false]) { posted.push(suffix); const body = req.postDataJSON(); expect(req.headers()['x-csrf-token']).toBe(auth.csrf_token); - if (suffix === (library ? '/script-revisions/' + script.revision_id + '/plan' : '/operation-plans')) { + if (suffix === (library ? '/script-revisions/' + revision.revision_id + '/plan' : '/operation-plans')) { expect(body.targets.asset_ids).toEqual([linux.asset_id]); expect(body.reason).toBe('Abnahme'); - const content = library ? script.script_utf8 : body.parameters.variants[0].script_utf8; + const content = library ? revision.script_utf8 : body.parameters.variants[0].script_utf8; const action = { action: 'run_script', interpreter: 'posix_sh', script_utf8: content, arguments: [], - expected_stdout: null + expected_stdout: null, + ...(restart ? { privileged_script_profile: 'full_maintenance_v1' } : {}) }; const payload = { schema_version: 1, @@ -326,7 +414,7 @@ for (const library of [true, false]) { job_id: randomUUID(), attempt_id: randomUUID(), action, - execution_identity: 'agent_service', + execution_identity: revision.execution_identity, not_before: body.schedule.not_before, start_before: body.schedule.start_before, max_runtime_seconds: library ? body.max_runtime_seconds : body.parameters.timeout_seconds, @@ -345,8 +433,8 @@ for (const library of [true, false]) { ...(library ? { script_revision: { - revision_id: script.revision_id, - name: script.name, + revision_id: revision.revision_id, + name: revision.name, version: 1, script_sha256: job.script_sha256 } @@ -383,12 +471,16 @@ for (const library of [true, false]) { if (library) await page.getByRole('checkbox', { name: /test-windows/ }).check(); await page.getByRole('button', { name: 'Weiter zum Skript' }).click(); if (library) { - await page.getByLabel('Bibliotheksskript').selectOption(script.name); + await page.getByLabel('Bibliotheksskript').selectOption(revision.name); await expect(page.getByRole('alert')).toContainText('test-windows'); await expect(page.getByRole('button', { name: 'Zusammenfassung ansehen' })).toBeDisabled(); await page.getByRole('button', { name: 'Zurück zu Geräten' }).click(); await page.getByRole('checkbox', { name: /test-windows/ }).uncheck(); await page.getByRole('button', { name: 'Weiter zum Skript' }).click(); + if (restart) { + await page.getByRole('button', { name: 'Neustartskript auswählen' }).click(); + await expect(page.getByRole('combobox', { name: 'Ausführen als', exact: true })).toHaveValue('root'); + } } else { await page.getByRole('radio', { name: 'Einmaliges Skript' }).check(); await page.getByLabel('Skriptinhalt').fill('uname\n'); @@ -409,7 +501,7 @@ for (const library of [true, false]) { await expect(page.locator('body')).toHaveAttribute('data-operation', /^[a-f0-9-]{36}$/); expect(await page.locator('body').getAttribute('data-operation')).toBe(operationId); expect(posted).toEqual([ - library ? '/script-revisions/' + script.revision_id + '/plan' : '/operation-plans', + library ? '/script-revisions/' + revision.revision_id + '/plan' : '/operation-plans', '/operation-plans/' + plan!.plan_id + '/submit' ]); expect(await page.evaluate(() => sessionStorage.length)).toBe(0); diff --git a/tests/linux_release_bootstrap.py b/tests/linux_release_bootstrap.py index db95f74..eb133fb 100644 --- a/tests/linux_release_bootstrap.py +++ b/tests/linux_release_bootstrap.py @@ -157,6 +157,20 @@ class ScriptHelperInstallation(unittest.TestCase): self.assertIn(b'lifecycle.py run-helper',files[self.unit]) self.assertIn(str(self.previous).encode(),self.unit.read_bytes()) + def test_service_environment_cannot_replace_restrictive_operator_pin_or_claim_a_release(self): + lifecycle.save(self.root / 'config.json', {'gateway':'https://127.0.0.1','tenant':self.previous}) + lifecycle.save(self.folder / 'script-pin.json',self.pin) + self.state.return_value = 'enabled' + environment = {'RMM_FULL_MAINTENANCE_POLICY_FILE':'/etc/site/restricted.json', + 'RMM_SCRIPT_HELPER_RELEASE':self.previous} + with patch.dict(lifecycle.os.environ,environment,clear=True), patch.object(lifecycle.os,'execv'): + lifecycle.run_agent() + self.assertEqual(lifecycle.os.environ['RMM_FULL_MAINTENANCE_POLICY_FILE'],'/etc/site/restricted.json') + self.assertNotIn('RMM_SCRIPT_HELPER_RELEASE',lifecycle.os.environ) + with patch.dict(lifecycle.os.environ,{},clear=True), patch.object(lifecycle.os,'execv'): + lifecycle.run_agent() + self.assertEqual(lifecycle.os.environ['RMM_SCRIPT_HELPER_RELEASE'],self.release) + def test_rejected_pair_does_not_run_candidate_and_altered_policy_stays_intact(self): with patch.object(lifecycle.subprocess,'check_output',side_effect=subprocess.CalledProcessError(1,'verify')) as run: with self.assertRaises(subprocess.CalledProcessError): diff --git a/web/README.md b/web/README.md index 1a75a1e..10b8c63 100644 --- a/web/README.md +++ b/web/README.md @@ -1,4 +1,4 @@ -# Linux-MVP WebUI +# Rust Discovery WebUI React/TypeScript, no runtime demo data, no desktop/PTY/hypervisor integration. Build assets: **`web/dist/`**; serve `index.html` and `/assets/*` from the TLS backend @@ -6,16 +6,27 @@ on the same origin. Do not proxy authentication to a different origin. All API U are relative; cookies use `credentials: same-origin`, mutations use `X-CSRF-Token`. No token or password persistence, raw HTML rendering, automatic approval or retry. +## Geräteaufträge + +Unter **Aufträge → Neuer Auftrag** wählen Sie die Geräte und eine veröffentlichte +Skriptversion oder geben ein einmaliges Skript ein. **Neustartskript auswählen** +übernimmt die passende Bibliotheksversion für Windows (PowerShell als SYSTEM) oder +Linux (Shell als root). Gebundene Skriptbytes, Zielgeräte, Rechte und Zeitgrenzen +sind vor der Entscheidung unter **Genehmigungen** sichtbar. Frühere typisierte +Aufträge bleiben in der Historie lesbar. Im Gerätedetail stehen die zuletzt vom +Agenten gemeldeten Ausführungsrechte. `full_maintenance_v1` bezeichnet das +technische Profil eines genehmigten Administratorskripts. + ## Commands From `web/`: `npm ci`, `npm run typecheck`, `npm test`, `npm run build`. `npm run dev` binds loopback, but is not the authenticated TLS acceptance setup. -The current server is `discovery.ease-technologies.de`; management access uses the -configured SSH tunnel and verified TLS. Earlier local `rmm-dev.internal:18443` +The public management service is documented in [public access](../docs/public-access.md). +The separate dev/test profile uses the SSH tunnel. Earlier local `rmm-dev.internal:18443` examples below are historical. The notebook is development only, without an RMM server or enrolled agent. No certificate-verification bypass is supported. -## Script console (specification 1.20, source implementation) +## Historical script console and adapter contracts (specification 1.20) `run_script` remains a durable plan/request, not a PTY or interactive terminal. The planner accepts complete fixed POSIX/Bash or Windows PowerShell5.1 scripts. @@ -69,7 +80,7 @@ independent scopes. Two output tests cover hostile HTML/terminal/bidi bytes, unknown/cancellation/truncation, invalid encodings and absent/invalid results. No browser, server, VM job, approval or deployment was executed in these checks. -## JSON adapter contract +### JSON adapter contract at the time of the historical tests `src/api.ts` is the sole transport/contract boundary. Responses missing required fields fail explicitly. Unknown backend fields are displayed without interpretation. @@ -153,7 +164,7 @@ visible; failed polling retains the old response alongside an error, never a gre success message. Tenant changes unmount all selection/plans/jobs and abort requests. List pagination uses server cursors, without pretending a truncated page is complete. -## Browser checks and separate acceptance gates +### Historical browser checks and separate acceptance gates `tests/browser/approval.spec.ts` uses actual UI interactions only. It never uses an API client to authorize, never writes storageState, and disables traces/screenshots/ diff --git a/web/src/devices.tsx b/web/src/devices.tsx index 2030433..4d816bd 100644 --- a/web/src/devices.tsx +++ b/web/src/devices.tsx @@ -15,6 +15,7 @@ import { import { AdminControl } from './management'; import { allowed } from './safety'; import { CatalogCheckNotice } from './catalog-check'; +import { devicePlatform } from './script-catalog'; import { ErrorBox, errorText, useResource } from './resource'; import { NavIcon, orderDetailRoute } from './navigation'; import { orderTitle, Status } from './order-presentation'; @@ -115,6 +116,22 @@ function devicePath(customer: string, asset: string) { return tenantPath(customer, '/devices/' + encodeURIComponent(asset)); } +function reportedScriptProfiles(device: RecordValue) { + const os = devicePlatform(device); + if (!os || !Array.isArray(device.capabilities)) return 'Nicht gemeldet'; + const caps = new Set(device.capabilities); + if (!caps.has('run_script')) return 'Nicht gemeldet'; + const windows = os === 'windows'; + const identity = windows ? 'system' : 'root'; + const service = windows ? 'PowerShell als Dienstkonto' : 'Shell als Dienstkonto'; + if (!caps.has(os + '.base/1') || caps.has(windows ? 'linux.base/1' : 'windows.base/1')) return 'Nicht gemeldet'; + if (windows && !['rmm.sync.v1', 'script.powershell/1', 'script.powershell.process_remote_signed/1'].every(cap => caps.has(cap))) + return 'Nicht gemeldet'; + const admin = ['rmm.sync.v1', 'script.full_maintenance/1', 'helper.' + identity + '.v1', identity + ':run_script'] + .every(capability => caps.has(capability)); + return admin ? service + ' und als Administrator (' + (windows ? 'SYSTEM' : 'root') + ')' : service; +} + function DeviceDetail({ customer, asset, @@ -158,7 +175,8 @@ function DeviceDetail({ ['Speicher frei / gesamt', capacity(d.disk_free_bytes, d.disk_total_bytes)], ['Letzter Kontakt', time(d.last_contact_at)], ['Inventar erhoben', time(d.observed_at)], - ['Agentversion', label(d.agent_version)] + ['Agentversion', label(d.agent_version)], + ['Vom Agenten gemeldete Skriptausführung', reportedScriptProfiles(d)] ]; return (
@@ -654,7 +672,7 @@ export function Devices({ - +
)} diff --git a/web/src/main.tsx b/web/src/main.tsx index 6729ea2..4313039 100644 --- a/web/src/main.tsx +++ b/web/src/main.tsx @@ -9,10 +9,10 @@ import { ScriptLibrary } from './script-library'; import { McpTokenManagement } from './mcp-token-management'; import React, { useEffect, useRef, useState } from 'react'; import { createRoot } from 'react-dom/client'; -import { actions, Action, ApiError, authConfig, approvalBlockers, expectedStdout, objectId, page, PlanInput, pretty, record, RecordValue, request, session, Session, stringField, tenant, tenantPath, validateInput, windowsPowerShellRemoteSignedProfile, fullMaintenanceScriptProfile } from './api'; +import { ApiError, authConfig, approvalBlockers, objectId, page, pretty, record, RecordValue, request, session, Session, stringField, tenant, tenantPath, windowsPowerShellRemoteSignedProfile, fullMaintenanceScriptProfile } from './api'; import './style.css'; import { AdminControl, Catalog, TenantControls } from './management'; -import { allowed, availableActions, parseStrictJson, powerShellApprovalBlockers, powerShellPlanJobs, rootWarning, systemWarning, systemPlanJobs, validateSensitiveInput, verifyPlanIntegrity, queryLogsApprovalBlockers, queryLogsPlanJobs, windowsMsiApprovalBlockers, windowsMsiPlanJobs, verifyWindowsMsiManifest, fullMaintenanceWarning } from './safety'; +import { allowed, parseStrictJson, powerShellApprovalBlockers, powerShellPlanJobs, rootWarning, systemWarning, systemPlanJobs, verifyPlanIntegrity, queryLogsApprovalBlockers, queryLogsPlanJobs, windowsMsiApprovalBlockers, windowsMsiPlanJobs, verifyWindowsMsiManifest, adminScriptWarning } from './safety'; import { Login } from './login'; import { ConsoleOutput, visibleControls } from './console-output'; import { scriptApprovalBlockers, scriptPlanJobs, verifyScriptPlan } from './script-console'; @@ -53,7 +53,7 @@ export function ScriptPlanNotice({ plan }: { plan: RecordValue }) { return target ? deviceName(target) : j.assetId; }).join(', ')}}

{job.revision ? job.revision.name+' · Version '+job.revision.version : 'Einmaliges Skript'} · {job.interpreter} · {identityName(job.identity)}

- {job.privilegedProfile === fullMaintenanceScriptProfile &&

{fullMaintenanceWarning}

} + {job.privilegedProfile === fullMaintenanceScriptProfile &&

{adminScriptWarning}

} {job.identity === 'root' && job.privilegedProfile !== fullMaintenanceScriptProfile &&

{rootWarning}

} {job.interpreter === 'powershell' &&

Windows PowerShell 5.1 · {job.windowsProfile === windowsPowerShellRemoteSignedProfile ? 'RemoteSigned für diesen Prozess' : 'Richtlinie des Geräts'}

}
{visibleControls(job.script)}
@@ -115,41 +115,6 @@ export function QueryLogsPlanNotice({ plan }: { plan: RecordValue }) { return ; } catch { return ; } } -const initialParameters: Record = { - run_script: {}, refresh_inventory: { scope: 'linux.base' }, query_logs: { unit: '', since: '', until: '', max_lines: 1000 }, set_service_state: { unit: '', state: 'running' }, ensure_package: { provider: 'apt', recipe_version: '', package: '', version: '', architecture: 'amd64', installation_context: 'system', apt_manifest: null }, apply_updates: { provider: 'apt', packages: [], reboot_policy: 'never', apt_manifest: null }, reboot: { reason: '', dependency_group: '', reconnect_timeout_seconds: 300 }, apt_native_acceptance: { recipe_id: 'rmm-apt-fixture-install-1.0', recipe_version: '1', apt_manifest: null }, - update_agent: { release_id: '' }, -}; -function Planner({ tenantId, auth, selected, showPlan }: { tenantId: string; auth: Session; selected: string[]; showPlan: (id: string) => void }) { - const choices = availableActions(auth, actions).filter(action => auth.principal.simulated || !['run_script', 'reboot'].includes(action)); - const [scriptPlatform, setScriptPlatform] = useState('linux'), [mixedVariants, setMixedVariants] = useState('[]'); - const initialAction = auth.principal.simulated ? 'run_script' : 'refresh_inventory'; - const [action, setAction] = useState(initialAction), [parameters, setParameters] = useState(pretty(initialParameters[initialAction])), [error, setError] = useState(null), [busy, setBusy] = useState(false); - const [identity, setIdentity] = useState('agent_service'); - return

Neuen unveränderlichen Plan vorbereiten

Nur fest ausgewählte Asset-IDs. Keine Ausführung durch Planung oder Antrag; jede Aktion einschließlich Live-Inventar benötigt Genehmigung.

-
{ e.preventDefault(); setBusy(true); setError(null); const f = new FormData(e.currentTarget); try { - const common = { execution_identity: String(f.get('identity')), timeout_seconds: Number(f.get('timeout')), max_output_bytes: Number(f.get('output')), ...(action === 'run_script' && f.get('privileged_script_profile') === fullMaintenanceScriptProfile ? { privileged_script_profile: fullMaintenanceScriptProfile } : {}) }; - const params = action === 'run_script' ? { ...common, variants: scriptPlatform === 'mixed' ? parseStrictJson(mixedVariants) : [{ os_family: scriptPlatform, interpreter: String(f.get('interpreter')), encoding: 'utf-8', script_utf8: String(f.get('script')), ...(scriptPlatform === 'windows' ? { windows_execution_profile: windowsPowerShellRemoteSignedProfile } : {}) }], arguments: [], expected_stdout: expectedStdout(String(f.get('expected')), String(f.get('expected_format'))) } : { ...record(parseStrictJson(parameters)), ...common }; - const input: PlanInput = { tenant_id: tenantId, action, targets: { asset_ids: [...selected] }, parameters: params, schedule: { not_before: new Date(String(f.get('not_before'))).toISOString(), start_before: new Date(String(f.get('expires'))).toISOString(), offline_policy: 'wait_until_deadline' }, rollout: { max_parallel: Number(f.get('parallel')), halt_after_failures: Number(f.get('failures')) }, reason: String(f.get('reason')) }; - const ids = String(f.get('artifact_ids') ?? '').split(/[\s,]+/).filter(Boolean); if (ids.length) { if (ids.length > 16 || new Set(ids).size !== ids.length || ids.some(id => !/^[0-9a-f-]{36}$/i.test(id))) throw new Error('Maximal 16 eindeutige feste Artefakt-UUIDs'); input.artifact_ids = ids; } - validateInput(input); await validateSensitiveInput(input, auth); const plan = record(await request(tenantPath(tenantId, '/operation-plans'), { body: input, csrf: auth.csrf_token })); showPlan(objectId(plan, 'plan')); - } catch (e) { setError(errorText(e)); } finally { setBusy(false); } }}> - - {action === 'update_agent' &&

{agentUpdateWarning} Nur parameters.release_id aus dem Katalog; keine freien Vorgänger-, Dateipfad-, Artefakt- oder Policywerte. Gesamtbudget600s, Ausgabelimit höchstens65536Bytes. Fehlende frische Gerätepreview ergibt keine Planung.

} - {action === 'query_logs' &&

Windows-MVP nur Quelle windows.eventlog.application.rustdiscovery-mvp-test, Kanal Application, Provider RustDiscovery-MVP-Test, agent_service. Festes UTC-Fenster höchstens24h,1–1000Events,1024–65536Bytes,äußere Joblaufzeit10–120s; inneres kooperatives Abfragebudget höchstens5000ms. Keine freie Kanal-/XPathauswahl und keine Bookmarkfortschreibung. Linux behält seine feste Journalunit.

} - {action === 'apt_native_acceptance' &&

NUR SIMULIERTE DEV/TEST-NATIVABNAHME. In Vorbereitung; Backend/Helper/Scope müssen diese eigene Aktion unterstützen. Nur rmm-apt-fixture-install-1.0 oder rmm-apt-fixture-update-1.1, Rezeptversion 1, vollständiges Schema-2-Manifest. null/Platzhalter sind nicht konfiguriert, keine Produktionsaktion, keine automatische Ausführung.

} - {action === 'run_script' ? <>{scriptPlatform === 'mixed' ?