Plan device actions exclusively as approved scripts and provide reboot library revisions

This commit is contained in:
2026-11-18 12:04:58 +01:00
parent adc04f0148
commit cd80bfc704
31 changed files with 1014 additions and 779 deletions
+1 -1
View File
@@ -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 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 ## Betrieb und Freigabe
+7 -1
View File
@@ -1,6 +1,6 @@
# Rust RMM: Architektur und Implementierungsspezifikation # 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. **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 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) ### 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. 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.
+14 -13
View File
@@ -588,11 +588,14 @@ async fn installed(
) -> Result<Response, Error> { ) -> Result<Response, Error> {
let (tenant, agent) = device(&s, peer, &headers).await?; let (tenant, agent) = device(&s, peer, &headers).await?;
let mut tx = rmm_persistence::tenant_tx(&s.pool, tenant).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?; tx.commit().await?;
Ok(( Ok((
[("cache-control", "private, no-store")], [("cache-control", "private, no-store")],
Json(json!({"agent_id":agent, Json(json!({"tenant_id":tenant,"asset_id":row.get::<Uuid,_>("asset_id"),"agent_id":agent,
"enrollment_generation":row.get::<i64,_>("enrollment_generation"),
"assignment_version":row.get::<i64,_>("assignment_version"),
"capabilities":row.get::<Value,_>("capabilities"),
"agent_version":row.get::<Option<String>,_>("reported_agent_version"), "agent_version":row.get::<Option<String>,_>("reported_agent_version"),
"connection_generation":row.get::<i64,_>("connection_generation"), "connection_generation":row.get::<i64,_>("connection_generation"),
"last_contact_at":row.get::<Option<chrono::DateTime<chrono::Utc>>,_>("last_contact_at")})), "last_contact_at":row.get::<Option<chrono::DateTime<chrono::Utc>>,_>("last_contact_at")})),
@@ -1256,19 +1259,17 @@ mod tests {
} }
} }
#[test] #[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"]}, 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}, "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"}); "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(); let tenant = Uuid::parse_str(value["tenant_id"].as_str().unwrap()).unwrap();
assert!(matches!(parsed, crate::jobs::PlanRequest::AgentUpdate(_))); for local_binding in [false, true] {
// The old synchronous resolver cannot manufacture local state. if local_binding {
assert!( value["parameters"]["predecessor"] = json!({"installed_record_sha256":"00".repeat(32)});
parsed }
.resolve(Uuid::parse_str(value["tenant_id"].as_str().unwrap()).unwrap()) let parsed: crate::jobs::PlanRequest = serde_json::from_value(value.clone()).unwrap();
.is_err() assert_eq!(parsed.resolve(tenant).err().unwrap().1, "SCRIPT_ACTION_REQUIRED");
); }
value["parameters"]["predecessor"] = json!({"installed_record_sha256":"00".repeat(32)});
assert!(serde_json::from_value::<crate::jobs::PlanRequest>(value).is_err());
} }
} }
+6 -4
View File
@@ -569,10 +569,12 @@ def run_agent():
RMM_RELEASE_LOCK=str(ROOT / 'release.lock'), RMM_RELEASE_LOCK=str(ROOT / 'release.lock'),
RMM_INSTALLED_RELEASE_VERSION=read(ROOT / 'current/manifest.json')['version']) RMM_INSTALLED_RELEASE_VERSION=read(ROOT / 'current/manifest.json')['version'])
folder = active_folder() 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'): 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), pins = {'RMM_FULL_MAINTENANCE_HELPER_SOCKET': str(HELPER_SOCKET),
RMM_FULL_MAINTENANCE_POLICY_FILE=str(folder / 'script-pin.json'), 'RMM_FULL_MAINTENANCE_POLICY_FILE': str(folder / 'script-pin.json')}
RMM_SCRIPT_HELPER_RELEASE=folder.name) 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') exe = str(folder / 'agent')
os.execv(exe, [exe]) os.execv(exe, [exe])
@@ -681,7 +683,7 @@ def main():
elif args.action == 'run-helper': elif args.action == 'run-helper':
require(os.geteuid() == 0, 'privileged script helper service required') require(os.geteuid() == 0, 'privileged script helper service required')
folder = active_folder() 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')]) os.execv(folder / 'helper', [str(folder / 'helper')])
elif args.action == 'run-agent': elif args.action == 'run-agent':
run_agent() run_agent()
+186 -341
View File
@@ -128,42 +128,38 @@ pub struct PlanInput {
#[serde(default)] #[serde(default)]
pub artifact_ids: Vec<Uuid>, pub artifact_ids: Vec<Uuid>,
} }
#[derive(Clone, Deserialize, schemars::JsonSchema)] #[derive(Clone, Deserialize)]
#[serde(untagged)] #[serde(untagged)]
pub enum PlanRequest { pub enum PlanRequest {
AgentUpdate(Box<AgentUpdatePlanInput>),
Typed(Box<PlanInput>),
Web(Box<WebPlanInput>), Web(Box<WebPlanInput>),
// Earlier SDKs sent the fixed script action instead of platform variants.
Typed(Box<PlanInput>),
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)] #[derive(Clone, Deserialize, schemars::JsonSchema)]
#[serde(deny_unknown_fields)] enum ScriptActionName {
pub struct AgentUpdatePlanInput { #[serde(rename = "run_script")]
tenant_id: Uuid, RunScript,
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,
} }
#[derive(Clone, Deserialize, schemars::JsonSchema)] #[derive(Clone, Deserialize, schemars::JsonSchema)]
#[serde(deny_unknown_fields)] #[serde(deny_unknown_fields)]
pub struct WebPlanInput { pub struct WebPlanInput {
tenant_id: Uuid, tenant_id: Uuid,
action: String, #[serde(rename = "action")]
_action: ScriptActionName,
targets: Targets, targets: Targets,
parameters: WebParameters, parameters: WebParameters,
schedule: WebSchedule, schedule: WebSchedule,
@@ -207,45 +203,25 @@ struct WebParameters {
execution_identity: String, execution_identity: String,
timeout_seconds: u32, timeout_seconds: u32,
max_output_bytes: u32, max_output_bytes: u32,
variants: Option<Vec<Variant>>, variants: Vec<Variant>,
arguments: Option<Vec<String>>, arguments: Option<Vec<String>>,
expected_stdout: Option<String>, expected_stdout: Option<String>,
scope: Option<String>,
unit: Option<String>,
state: Option<String>,
since: Option<DateTime<Utc>>,
until: Option<DateTime<Utc>>,
max_lines: Option<u32>,
provider: Option<String>,
package: Option<String>,
version: Option<String>,
architecture: Option<String>,
recipe_version: Option<String>,
recipe_id: Option<String>,
apt_manifest: Option<rmm_domain::apt_transaction::AptExecutionManifest>,
#[serde(
default,
deserialize_with = "rmm_domain::jobs::deserialize_windows_msi_manifest"
)]
#[schemars(with = "rmm_domain::windows_execution::ResolvedWindowsMsi")]
windows_msi_manifest: Option<Box<rmm_domain::windows_execution::ResolvedWindowsMsi>>,
installation_context: Option<String>,
packages: Option<Vec<String>>,
reboot_policy: Option<String>,
reason: Option<String>,
dependency_group: Option<String>,
reconnect_timeout_seconds: Option<u32>,
} }
impl PlanRequest { impl PlanRequest {
pub fn resolve(self, tenant: Uuid) -> Result<PlanInput> { pub fn resolve(self, tenant: Uuid) -> Result<PlanInput> {
let w = match self { let w = match self {
Self::AgentUpdate(_) => { Self::Typed(input) => {
return Err(Error( require_script(&input.action)?;
StatusCode::BAD_REQUEST, return Ok(*input);
"AGENT_UPDATE_RELEASE_ID_REQUIRED", }
)); 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, Self::Web(w) => *w,
}; };
if w.tenant_id != tenant { if w.tenant_id != tenant {
@@ -254,105 +230,21 @@ impl PlanRequest {
if w.schedule.offline_policy != "wait_until_deadline" { if w.schedule.offline_policy != "wait_until_deadline" {
return Err(fail("POLICY_DENIED")); 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; let p = w.parameters;
if p.windows_msi_manifest.is_some() && w.action != "ensure_package" { validate_variants(&p.variants)?;
return Err(Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR")); let first = &p.variants[0];
} let action = Action::RunScript {
let required = interpreter: first.interpreter.clone(),
|value: Option<String>| value.ok_or(Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR")); script_utf8: first.script_utf8.clone(),
let action = match w.action.as_str() { arguments: p.arguments.unwrap_or_default(),
"run_script" => { expected_stdout: p.expected_stdout,
let variants = p windows_execution_profile: first.windows_execution_profile,
.variants privileged_script_profile: p.privileged_script_profile,
.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")),
}; };
// 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 { Ok(PlanInput {
targets: w.targets, targets: w.targets,
action, action,
script_variants: p.variants.unwrap_or_default(), script_variants: p.variants,
execution_identity: p.execution_identity, execution_identity: p.execution_identity,
schedule: Schedule { schedule: Schedule {
not_before: w.schedule.not_before, 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 /// HTTP and MCP prepare the same tenant-scoped, immutable script plans.
/// saved authenticated per-device observations. Caller-supplied local pins are
/// never an alternative route to the typed immutable execution payload.
pub async fn plan_request( pub async fn plan_request(
state: &crate::State, state: &crate::State,
p: &Principal, p: &Principal,
tenant: Uuid, tenant: Uuid,
request: PlanRequest, request: PlanRequest,
) -> Result<Value> { ) -> Result<Value> {
let PlanRequest::AgentUpdate(input) = request else {
return plan(state, p, tenant, request.resolve(tenant)?).await;
};
scope(p, tenant, true)?; scope(p, tenant, true)?;
if input.tenant_id != tenant { plan(state, p, tenant, request.resolve(tenant)?).await
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
} }
fn require_script(action: &Action) -> Result<()> {
if matches!(action, Action::RunScript { .. }) {
Ok(())
} else {
Err(fail("SCRIPT_ACTION_REQUIRED"))
}
}
fn validate_variants(variants: &[Variant]) -> Result<()> { fn validate_variants(variants: &[Variant]) -> Result<()> {
if variants.is_empty() || variants.len() > 2 { if variants.is_empty() || variants.len() > 2 {
return Err(fail("AMBIGUOUS_TARGET")); return Err(fail("AMBIGUOUS_TARGET"));
@@ -531,25 +380,17 @@ pub async fn plan(
tenant: Uuid, tenant: Uuid,
input: PlanInput, input: PlanInput,
) -> Result<Value> { ) -> Result<Value> {
if matches!(input.action, Action::UpdateAgent { .. }) { plan_resolved(state, p, tenant, input, None).await
return Err(Error(
StatusCode::BAD_REQUEST,
"AGENT_UPDATE_RELEASE_ID_REQUIRED",
));
}
plan_resolved(state, p, tenant, input, None, None).await
} }
pub(crate) async fn plan_resolved( pub(crate) async fn plan_resolved(
state: &crate::State, state: &crate::State,
p: &Principal, p: &Principal,
tenant: Uuid, tenant: Uuid,
input: PlanInput, input: PlanInput,
updates: Option<
std::collections::BTreeMap<Uuid, rmm_domain::agent_update::ResolvedAgentUpdate>,
>,
script_revision: Option<ScriptRevisionReference>, script_revision: Option<ScriptRevisionReference>,
) -> Result<Value> { ) -> Result<Value> {
scope(p, tenant, true)?; scope(p, tenant, true)?;
require_script(&input.action)?;
let now = Utc::now(); let now = Utc::now();
if input.targets.asset_ids.is_empty() if input.targets.asset_ids.is_empty()
|| input.targets.asset_ids.len() > 100 || input.targets.asset_ids.len() > 100
@@ -574,33 +415,6 @@ pub(crate) async fn plan_resolved(
{ {
return Err(Error(StatusCode::BAD_REQUEST, "VALIDATION_ERROR")); 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(); let mut ids = input.targets.asset_ids.clone();
ids.sort(); ids.sort();
ids.dedup(); ids.dedup();
@@ -610,25 +424,7 @@ pub(crate) async fn plan_resolved(
for permission in execution_permissions(&input.action, &input.execution_identity) { for permission in execution_permissions(&input.action, &input.execution_identity) {
crate::permissions::require_principal(&mut tx, p, permission).await?; crate::permissions::require_principal(&mut tx, p, permission).await?;
} }
let recipe_references = crate::catalog::references(&mut tx, &input.action).await?; let artifacts = crate::catalog::resolve_artifacts(&mut tx, tenant, &input.artifact_ids).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 mut jobs = Vec::new(); let mut jobs = Vec::new();
for asset in ids { 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?; 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 row = &rows[0];
let caps = capabilities(row.get("capabilities"))?; let caps = capabilities(row.get("capabilities"))?;
let action = if let Some(updates) = &updates { let action = target_action(&input, &caps)?;
Action::UpdateAgent {
update: Box::new(
updates
.get(&asset)
.ok_or_else(|| fail("AGENT_UPDATE_STATE_NOT_CONFIGURED"))?
.clone(),
),
}
} else {
target_action(&input, &caps)?
};
if !action.valid_job_limits(input.max_runtime_seconds, input.max_output_bytes) { if !action.valid_job_limits(input.max_runtime_seconds, input.max_output_bytes) {
return Err(fail("VALIDATION_ERROR")); return Err(fail("VALIDATION_ERROR"));
} }
@@ -709,7 +494,7 @@ pub(crate) async fn plan_resolved(
jobs, jobs,
max_parallel: input.rollout.max_parallel, max_parallel: input.rollout.max_parallel,
halt_after_failures: input.rollout.halt_after_failures, halt_after_failures: input.rollout.halt_after_failures,
recipe_references, recipe_references: Vec::new(),
artifact_references, artifact_references,
script_revision, script_revision,
}; };
@@ -807,6 +592,7 @@ pub(crate) async fn authorize_approved_job(
job: &JobPayload, job: &JobPayload,
row: &sqlx::postgres::PgRow, row: &sqlx::postgres::PgRow,
) -> Result<()> { ) -> Result<()> {
require_script(&job.action)?;
let participants = JobParticipants { let participants = JobParticipants {
planner: &plan.principal, planner: &plan.principal,
submitter: row.get("submitter"), submitter: row.get("submitter"),
@@ -966,7 +752,8 @@ pub async fn submit(
let request_hash = hash(id.as_bytes()); let request_hash = hash(id.as_bytes());
let (plan, _, _) = load_plan(&mut tx, id).await?; let (plan, _, _) = load_plan(&mut tx, id).await?;
for job in &plan.jobs { 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?; crate::permissions::require_principal(&mut tx, p, permission).await?;
} }
@@ -993,6 +780,9 @@ pub async fn submit(
tx.commit().await?; tx.commit().await?;
return operation(state, p, tenant, op).await; return operation(state, p, tenant, op).await;
} }
for job in &plan.jobs {
require_script(&job.payload.action)?;
}
recheck(&mut tx, &plan).await?; recheck(&mut tx, &plan).await?;
let op = Uuid::new_v4(); 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?; 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, submitter,
approver: &approver.name, 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 { for job in &plan.jobs {
require_script(&job.payload.action)?;
if execution_permissions(&job.payload.action, &job.payload.execution_identity) if execution_permissions(&job.payload.action, &job.payload.execution_identity)
.any(|permission| !approver.permits_scope(permission)) .any(|permission| !approver.permits_scope(permission))
{ {
@@ -1118,8 +911,15 @@ pub async fn requester_enabled(
if name.starts_with("mcp:") { if name.starts_with("mcp:") {
crate::mcp_tokens::issuer_enabled(state, tx, name).await crate::mcp_tokens::issuer_enabled(state, tx, name).await
} else if name.starts_with("local:") { } else if name.starts_with("local:") {
let Some(home)=state.auth.local.as_ref().and_then(|local|local.home(name)) else {return Ok(false);}; let Some(home) = state.auth.local.as_ref().and_then(|local| local.home(name)) else {
sqlx::query_scalar("SELECT $3=ANY(local_customer_tenants($1,$2))").bind(name).bind(home).bind(tenant).fetch_one(&mut **tx).await 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 { } else {
Ok(state.auth.operator_enabled(name, tenant)) 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()); assert!(target_action(&i, &["windows.base/1".into()]).is_err());
} }
#[test] #[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 tenant = Uuid::new_v4();
let now = Utc::now(); let typed = serde_json::to_value(input()).unwrap();
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 request: PlanRequest = serde_json::from_value(typed.clone()).unwrap();
let input = serde_json::from_value::<PlanRequest>(value.clone()) assert!(matches!(
.unwrap() request.resolve(tenant).unwrap().action,
.resolve(tenant) Action::RunScript { .. }
.unwrap(); ));
assert!(input.action.is_windows_event_log_fixture()); let mut retired = typed;
assert!(input.action.validate()); retired["action"] = json!({"action":"refresh_inventory", "scope":"linux.base"});
assert!( let request: PlanRequest = serde_json::from_value(retired).unwrap();
input assert_eq!(
.action request.resolve(tenant).err().unwrap().1,
.valid_job_limits(input.max_runtime_seconds, input.max_output_bytes) "SCRIPT_ACTION_REQUIRED"
); );
assert!(input.script_variants.is_empty());
for field in ["channel", "provider", "xpath", "bookmark"] { for action in [
let mut bad = value.clone(); "reboot",
bad["parameters"][field] = json!("arbitrary"); "query_logs",
assert!( "set_service_state",
serde_json::from_value::<PlanRequest>(bad) "update_agent",
.map(|request| request.resolve(tenant).is_err()) "future-action",
.unwrap_or(true) ] {
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::<PlanRequest>(
json!({"tenant_id":tenant, "action":"run_script", "parameters":{"unit":"x"}})
)
.is_err()
);
} }
#[test] #[test]
fn full_maintenance_web_profile_is_action_wide_strict_and_identity_bound() { 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::<WebParameters>(json!({"execution_identity":"agent_service", "timeout_seconds":60, "max_output_bytes":4096, "windows_execution_profile":"powershell_51_remote_signed"})).is_err()); assert!(serde_json::from_value::<WebParameters>(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] #[tokio::test]
#[ignore = "requires dedicated isolated PostgreSQL; tests/windows_plan_database.py"] #[ignore = "requires dedicated isolated PostgreSQL; tests/windows_plan_database.py"]
async fn windows_plan_caps_persisted_database() { async fn windows_plan_caps_persisted_database() {
@@ -1824,8 +1690,10 @@ mod windows_contract_tests {
.execute(&admin) .execute(&admin)
.await .await
.unwrap(); .unwrap();
crate::script_library::tests::revision_plan_contract(&state, &principal, assets[0], assets[1]) crate::script_library::tests::revision_plan_contract(
.await; &state, &principal, assets[0], assets[1],
)
.await;
let view = plan(&state, &principal, tenant, profiled).await.unwrap(); let view = plan(&state, &principal, tenant, profiled).await.unwrap();
let profile_id = Uuid::parse_str(view["plan_id"].as_str().unwrap()).unwrap(); let profile_id = Uuid::parse_str(view["plan_id"].as_str().unwrap()).unwrap();
let bytes: Vec<u8> = let bytes: Vec<u8> =
@@ -1914,16 +1782,9 @@ mod windows_contract_tests {
.await .await
.unwrap_err() .unwrap_err()
.1, .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(); 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(); let mut log_caps = windows_caps.as_array().unwrap().clone();
log_caps.extend([ log_caps.extend([
json!("query_logs"), json!("query_logs"),
@@ -1935,21 +1796,14 @@ mod windows_contract_tests {
.execute(&admin) .execute(&admin)
.await .await
.unwrap(); .unwrap();
let view = plan(&state, &principal, tenant, logs).await.unwrap(); let log_bound = historical_fixture(&state, &bound, &logs).await;
let log_id = Uuid::parse_str(view["plan_id"].as_str().unwrap()).unwrap(); let log_id = log_bound.plan_id;
let bytes: Vec<u8> =
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 mut tx = rmm_persistence::tenant_tx(&state.pool, tenant) let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant)
.await .await
.unwrap(); .unwrap();
recheck(&mut tx, &log_bound).await.unwrap(); recheck(&mut tx, &log_bound).await.unwrap();
tx.rollback().await.unwrap(); tx.rollback().await.unwrap();
let pending = submit( let blocked = submit(
&state, &state,
&principal, &principal,
tenant, tenant,
@@ -1959,9 +1813,8 @@ mod windows_contract_tests {
}, },
) )
.await .await
.unwrap(); .unwrap_err();
assert_eq!(pending["approval_state"], "pending_approval"); assert_eq!(blocked.1, "SCRIPT_ACTION_REQUIRED");
assert_eq!(pending["job_count"], 0);
let mut changed = log_bound.clone(); let mut changed = log_bound.clone();
if let Action::QueryLogs { max_lines, .. } = &mut changed.jobs[0].payload.action { if let Action::QueryLogs { max_lines, .. } = &mut changed.jobs[0].payload.action {
*max_lines = 999; *max_lines = 999;
@@ -2122,21 +1975,14 @@ mod windows_contract_tests {
package.action = crate::windows_msi_catalog::test_action(manifest.clone()); package.action = crate::windows_msi_catalog::test_action(manifest.clone());
package.max_runtime_seconds = 30; package.max_runtime_seconds = 30;
package.max_output_bytes = 4096; package.max_output_bytes = 4096;
let mut extra = package.clone();
extra.artifact_ids = vec![artifact_id];
assert_eq!( assert_eq!(
plan(&state, &principal, tenant, extra).await.unwrap_err().1, plan(&state, &principal, tenant, package.clone())
"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<u8> =
sqlx::query_scalar("SELECT payload FROM operation_plans WHERE plan_id=$1")
.bind(package_id)
.fetch_one(&admin)
.await .await
.unwrap(); .unwrap_err()
let fixed: PlanPayload = serde_json::from_slice(&raw).unwrap(); .1,
"SCRIPT_ACTION_REQUIRED"
);
let fixed = historical_fixture(&state, &bound, &package).await;
assert_eq!(fixed.artifact_references.len(), 1); assert_eq!(fixed.artifact_references.len(), 1);
assert_eq!( assert_eq!(
fixed.artifact_references[0].artifact.artifact_id, fixed.artifact_references[0].artifact.artifact_id,
@@ -2163,19 +2009,18 @@ mod windows_contract_tests {
assert!(recheck(&mut tx, &bad).await.is_err()); assert!(recheck(&mut tx, &bad).await.is_err());
tx.rollback().await.unwrap(); tx.rollback().await.unwrap();
} }
let pending = submit( let blocked = submit(
&state, &state,
&principal, &principal,
tenant, tenant,
package_id, fixed.plan_id,
Submit { Submit {
idempotency_key: "fixed-msi-metadata".into(), idempotency_key: "fixed-msi-metadata".into(),
}, },
) )
.await .await
.unwrap(); .unwrap_err();
assert_eq!(pending["approval_state"], "pending_approval"); assert_eq!(blocked.1, "SCRIPT_ACTION_REQUIRED");
assert_eq!(pending["job_count"], 0);
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(); 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) let mut tx = rmm_persistence::tenant_tx(&state.pool, tenant)
.await .await
+2 -2
View File
@@ -486,8 +486,8 @@ mod tests {
assert_eq!(directory["items"].as_array().unwrap().len(), 1); assert_eq!(directory["items"].as_array().unwrap().len(), 1);
assert_eq!(directory["items"][0]["tenant_id"], a.to_string()); assert_eq!(directory["items"][0]["tenant_id"], a.to_string());
let now = Utc::now(); let now = Utc::now();
let forbidden_plan = json!({"tenant_id":b,"action":"refresh_inventory","targets":{"asset_ids":[asset]}, 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,"scope":"base"}, "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"}, "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"}); "rollout":{"max_parallel":1,"halt_after_failures":1},"reason":"test customer authorization"});
for request in [ for request in [
+267 -6
View File
@@ -2,9 +2,14 @@
//! Plan submission, interactive approval and signed start grants are unchanged. //! Plan submission, interactive approval and signed start grants are unchanged.
use crate::{jobs::Error, root_policy::RootScope, windows_policy::SystemScope}; use crate::{jobs::Error, root_policy::RootScope, windows_policy::SystemScope};
use axum::http::StatusCode; 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 serde::Deserialize;
use sqlx::{Postgres, Transaction};
use std::{fs, os::unix::fs::MetadataExt, path::Path}; use std::{fs, os::unix::fs::MetadataExt, path::Path};
use uuid::Uuid;
#[derive(Deserialize)] #[derive(Deserialize)]
#[serde(deny_unknown_fields)] #[serde(deny_unknown_fields)]
@@ -12,6 +17,76 @@ struct Policy {
schema_version: u8, schema_version: u8,
linux: Vec<RootScope>, linux: Vec<RootScope>,
windows: Vec<SystemScope>, windows: Vec<SystemScope>,
#[serde(default)]
release_anchors: Vec<ReleaseAnchor>,
}
/// 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<String> {
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 { fn invalid() -> Error {
@@ -24,19 +99,72 @@ impl Policy {
|| !job.action.full_maintenance() || !job.action.full_maintenance()
|| !job.action.validate() || !job.action.validate()
|| !job.action.available_for(&job.execution_identity, caps) || !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; return false;
} }
match job.execution_identity.as_str() { match job.execution_identity.as_str() {
"root" => self.linux.iter().any(|scope| scope.permits(principal, job, caps, None)), "root" => self
"system" => self.windows.iter().any(|scope| scope.permits(principal, job, caps, false, true, false)), .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, _ => false,
} }
} }
} }
pub(crate) fn permits(principal: &str, job: &JobPayload, caps: &[String]) -> Result<bool, Error> { 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<bool, Error> {
if !job.action.full_maintenance() { if !job.action.full_maintenance() {
return Ok(false); 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())?; let policy: Policy = serde_json::from_slice(&bytes).map_err(|_| invalid())?;
if policy.schema_version != 1 if policy.schema_version != 1
|| policy.linux.len() + policy.windows.len() > 64 || 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) || !policy.windows.iter().all(SystemScope::valid)
{ {
return Err(invalid()); 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<String> = 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());
}
} }
+37 -6
View File
@@ -58,6 +58,7 @@ struct Device {
#[serde(deny_unknown_fields)] #[serde(deny_unknown_fields)]
struct Plan { struct Plan {
tenant_id: Uuid, tenant_id: Uuid,
#[schemars(with = "crate::jobs::WebPlanInput")]
input: crate::jobs::PlanRequest, input: crate::jobs::PlanRequest,
} }
#[derive(Deserialize, schemars::JsonSchema)] #[derive(Deserialize, schemars::JsonSchema)]
@@ -138,11 +139,11 @@ fn tools() -> Vec<Tool> {
), ),
tool::<crate::monitoring::LogQuery>( tool::<crate::monitoring::LogQuery>(
"logs.query", "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::<Plan>( tool::<Plan>(
"operations.plan", "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::<Submit>( tool::<Submit>(
"operations.submit", "operations.submit",
@@ -156,10 +157,6 @@ fn tools() -> Vec<Tool> {
"jobs.cancel", "jobs.cancel",
"Request cancellation, not rollback or proof of termination.", "Request cancellation, not rollback or proof of termination.",
), ),
tool::<Tenant>(
"sessions.request",
"Unsupported until after MVP; never opens a shell.",
),
] ]
} }
fn parse<T: serde::de::DeserializeOwned>(v: Value) -> Result<T, crate::jobs::Error> { fn parse<T: serde::de::DeserializeOwned>(v: Value) -> Result<T, crate::jobs::Error> {
@@ -400,3 +397,37 @@ pub fn routes(r: Router<crate::State>, state: crate::State) -> Router<crate::Sta
r.nest_service("/mcp", service) r.nest_service("/mcp", service)
.route_layer(middleware::from_fn_with_state(state, guard)) .route_layer(middleware::from_fn_with_state(state, guard))
} }
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn plan_tool_advertises_the_script_wire_contract() {
let tools = tools();
let plan = tools
.iter()
.find(|tool| tool.name == "operations.plan")
.unwrap();
let schema = serde_json::to_string(&plan.input_schema).unwrap();
for field in [
"run_script",
"script_utf8",
"variants",
"execution_identity",
] {
assert!(schema.contains(field), "{field}");
}
for retired in [
"update_agent",
"reboot",
"query_logs",
"apt_manifest",
"windows_msi_manifest",
"dependency_group",
] {
assert!(!schema.contains(retired), "{retired}");
}
assert!(tools.iter().all(|tool| tool.name != "sessions.request"));
}
}
+7 -83
View File
@@ -34,7 +34,10 @@ pub struct LogQuery {
pub since: DateTime<Utc>, pub since: DateTime<Utc>,
pub until: DateTime<Utc>, pub until: DateTime<Utc>,
pub max_lines: u32, pub max_lines: u32,
#[serde(default)]
#[schemars(skip)]
pub live: bool, pub live: bool,
#[schemars(skip)]
pub idempotency_key: Option<String>, pub idempotency_key: Option<String>,
} }
/// Both result endpoints use the reader's current token scope and tenant membership. /// Both result endpoints use the reader's current token scope and tenant membership.
@@ -83,89 +86,10 @@ pub async fn query(
)); ));
} }
if i.live { if i.live {
let request_hash = rmm_domain::jobs::hash(&serde_json::to_vec(&i)?); return Err(crate::jobs::Error(
let mut dedup = rmm_persistence::tenant_tx(&s.pool, i.tenant_id).await?; StatusCode::CONFLICT,
let key = i "SCRIPT_ACTION_REQUIRED",
.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::<String,_>("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::<String, _>("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;
} }
let mut tx = rmm_persistence::tenant_tx(&s.pool, i.tenant_id).await?; let mut tx = rmm_persistence::tenant_tx(&s.pool, i.tenant_id).await?;
let access = LogReadAccess::for_principal(&mut tx, p).await?; let access = LogReadAccess::for_principal(&mut tx, p).await?;
+1 -1
View File
@@ -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: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<String> = serde_json::from_value(caps)?; let caps: Vec<String> = 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(()); return Ok(());
} }
let policy = load()?; let policy = load()?;
+15 -2
View File
@@ -186,7 +186,7 @@ pub async fn plan(
reason: input.reason, reason: input.reason,
artifact_ids: vec![], 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> { 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 tenant = p.tenant;
let initial = list(s, p, tenant, PageQuery::default()).await.unwrap(); let initial = list(s, p, tenant, PageQuery::default()).await.unwrap();
let items = initial["items"].as_array().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 let template = items
.iter() .iter()
.find(|item| item["name"] == "Windows-Updates installieren") .find(|item| item["name"] == "Windows-Updates installieren")
+2 -1
View File
@@ -72,7 +72,8 @@ pub async fn references(
checked(tx, m).await?; checked(tx, m).await?;
Ok(vec![reference(m)]) Ok(vec![reference(m)])
} }
pub async fn automatic_artifacts( #[cfg(test)]
pub(crate) async fn automatic_artifacts(
tx: &mut Transaction<'_, Postgres>, tx: &mut Transaction<'_, Postgres>,
tenant: Uuid, tenant: Uuid,
action: &Action, action: &Action,
+66 -9
View File
@@ -38,6 +38,8 @@ pub(crate) struct SystemScope {
acceptance_evidence_id: Uuid, acceptance_evidence_id: Uuid,
allowed_services: Vec<String>, allowed_services: Vec<String>,
#[serde(default, deserialize_with = "strict_optional_hashes")] #[serde(default, deserialize_with = "strict_optional_hashes")]
allowed_script_sha256: Option<Vec<String>>,
#[serde(default, deserialize_with = "strict_optional_hashes")]
allowed_msi_recipe_sha256: Option<Vec<String>>, allowed_msi_recipe_sha256: Option<Vec<String>>,
max_runtime_seconds: u32, max_runtime_seconds: u32,
#[serde( #[serde(
@@ -97,6 +99,15 @@ impl SystemScope {
.collect::<std::collections::BTreeSet<_>>() .collect::<std::collections::BTreeSet<_>>()
.len() .len()
== self.principals.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::<std::collections::BTreeSet<_>>()
.len()
== hashes.len()
})
&& self.allowed_services.len() <= 16 && self.allowed_services.len() <= 16
&& self && self
.allowed_services .allowed_services
@@ -178,8 +189,16 @@ impl SystemScope {
&& has("system:set_service_state") && has("system:set_service_state")
&& has("set_service_state") && has("set_service_state")
} }
Action::RunScript { .. } => { Action::RunScript {
script_utf8,
arguments,
..
} => {
allow_scripts 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() && job.action.full_maintenance()
&& (self.allowed_script_profiles.as_ref().is_some_and(|v| { && (self.allowed_script_profiles.as_ref().is_some_and(|v| {
v.contains( 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 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<String> = serde_json::from_value(caps)?; let capabilities: Vec<String> = 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(()); return Ok(());
} }
let policy = load()?; let policy = load()?;
@@ -569,6 +588,27 @@ mod tests {
policy.schema_version = 3; policy.schema_version = 3;
assert!(policy.permits("selected", &job, &caps, Utc::now())); assert!(policy.permits("selected", &job, &caps, Utc::now()));
assert!(!policy.permits("foreign", &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(); let general = job.action.clone();
job.action = Action::RunScript { job.action = Action::RunScript {
interpreter: "powershell".into(), interpreter: "powershell".into(),
@@ -600,13 +640,25 @@ mod tests {
} }
#[test] #[test]
fn windows_update_window_accepts_only_the_two_fixed_scripts() { 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(); let (mut policy, mut job, mut caps) = fixture();
policy.schema_version = 3; policy.schema_version = 3;
let scope = &mut policy.scopes[0]; let scope = &mut policy.scopes[0];
scope.allowed_services.clear(); scope.allowed_services.clear();
scope.windows_update_max_runtime_seconds = Some(3600); 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 [ for (script, seconds, expected) in [
(WINDOWS_UPDATE_SCRIPT_UTF8, 3600, true), (WINDOWS_UPDATE_SCRIPT_UTF8, 3600, true),
(WINDOWS_UPDATE_IDENTITY_PROBE, 30, true), (WINDOWS_UPDATE_IDENTITY_PROBE, 30, true),
@@ -614,13 +666,18 @@ mod tests {
("Write-Output 12", 30, false), ("Write-Output 12", 30, false),
] { ] {
job.action = Action::RunScript { job.action = Action::RunScript {
interpreter:"powershell".into(), script_utf8:script.into(), interpreter: "powershell".into(),
arguments:vec![], expected_stdout:None, script_utf8: script.into(),
windows_execution_profile:Some(WindowsExecutionProfile::PowerShell51RemoteSigned), arguments: vec![],
privileged_script_profile:Some(PrivilegedScriptProfile::FullMaintenanceV1), expected_stdout: None,
windows_execution_profile: Some(WindowsExecutionProfile::PowerShell51RemoteSigned),
privileged_script_profile: Some(PrivilegedScriptProfile::FullMaintenanceV1),
}; };
job.max_runtime_seconds = seconds; 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] #[test]
+5 -7
View File
@@ -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) **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 | | Auftrag | Abnahmekriterium für Version 1.39 |
| --- | --- | --- | | --- | --- |
| 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. | | 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 | 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) | | 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 | 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) | | 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. |
| 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. |
**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 ## Ergänzte Lieferungen am 17. November 2026
+5 -1
View File
@@ -1,6 +1,10 @@
# Verbindliche Projektentscheidungen # 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) ## Offizieller Windows-x64-Release (Version 1.38, 18. November 2026)
+6
View File
@@ -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. 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 ## 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. 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.
+44
View File
@@ -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$;
+4 -1
View File
@@ -138,7 +138,9 @@ test('removes the confirmed historical installation and keeps its successor', as
await page.route(origin + '/api/v1/**', async r => { await page.route(origin + '/api/v1/**', async r => {
const req = r.request(), url = new URL(req.url()); const req = r.request(), url = new URL(req.url());
const historical = { ...device, agent_id: old, lifecycle: revoked ? 'revoked' : 'replaced', status: 'offline' }; 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/tenants') return r.fulfill({ json: listing([customer]) });
if (url.pathname === '/api/v1/devices' || url.pathname === path.slice(0, path.lastIndexOf('/'))) { 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]) }); 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: 'Bestand' }).click();
await page.getByRole('button', { name: 'NORD-PC' }).click(); await page.getByRole('button', { name: 'NORD-PC' }).click();
await expect(page).toHaveURL(new RegExp(active + '$')); 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 page.getByText('Gerät verwalten', { exact: true }).click();
await expect(page.getByRole('button', { name: 'Kopplung löschen' })).toHaveCount(0); await expect(page.getByRole('button', { name: 'Kopplung löschen' })).toHaveCount(0);
await expect(page.getByText('Geräteidentität widerrufen', { exact: true })).toBeVisible(); await expect(page.getByText('Geräteidentität widerrufen', { exact: true })).toBeVisible();
+4 -5
View File
@@ -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: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 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:'Erweitert',exact:true}).click();
await page.getByRole('link', { name: 'Wartungsauftrag planen', exact: true }).click(); await expect(page.getByRole('link', { name: 'Wartungsauftrag planen' })).toHaveCount(0);
await test.step('management:action-option', async () => { await expect(page.getByLabel('Aktion', { exact: true }).locator('option[value="apt_native_acceptance"]')).toHaveCount(1); }); await page.getByRole('link', { name: 'Aufträge', exact: true }).click();
await test.step('management:select-native', async () => { await page.getByLabel('Aktion', { exact: true }).selectOption('apt_native_acceptance'); }); await page.getByRole('link', { name: 'Neuer Auftrag', exact: true }).click();
await test.step('management:native-hint', async () => { await expect(page.getByText('NUR SIMULIERTE DEV/TEST-NATIVABNAHME.', { exact: false })).toBeVisible(); }); await expect(page.getByRole('heading', { name: 'Geräte auswählen' })).toBeVisible();
await test.step('management:identity-unchanged', async () => { await expect(page.getByLabel('Ausführungsidentität', { exact: true })).toHaveValue('agent_service'); });
await test.step('management:inert-controls', async () => { expect(mutations).toBe(0); }); 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(); }); 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(); });
}); });
+26 -30
View File
@@ -26,7 +26,7 @@ test('simulated human prepares root request through UI only, without approving',
const request = object(expected.request), params = object(request.parameters); const request = object(expected.request), params = object(request.parameters);
expect(params.execution_identity).toBe('root'); expect(params.execution_identity).toBe('root');
expect(object(request.targets).asset_ids).toEqual([expected.asset_id]); 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; let authorizationRequests = 0;
page.on('request', r => { if (new URL(r.url()).pathname.endsWith('/authorizations')) authorizationRequests++; }); 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); 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('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: 'Aufträge', exact: true }).click();
await page.getByRole('link', { name: 'Neuer Auftrag', 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('button', { name: 'Weiter zum Skript', exact: true }).click();
await page.getByRole('link', { name: 'Erweitert', exact: true }).click(); await page.getByRole('radio', { name: 'Einmaliges Skript' }).check();
await page.getByRole('link', { name: 'Wartungsauftrag planen', exact: true }).click(); const variants = params.variants;
await page.getByLabel('Aktion', { exact: true }).selectOption(text(request.action)); if (!Array.isArray(variants) || variants.length !== 1) throw new Error('One exact script variant required');
if (request.action === 'run_script') { const variant = object(variants[0]);
const variants = params.variants; await page.getByLabel('Plattform und Interpreter').selectOption(text(variant.interpreter));
if (!Array.isArray(variants) || variants.length !== 1) throw new Error('One exact script variant required'); await page.getByLabel('Skriptinhalt', { exact: true }).fill(text(variant.script_utf8));
const variant = object(variants[0]); await page.getByLabel('Ausführen als', { exact: true }).selectOption('root');
await page.getByRole('combobox', { name: 'Interpreter', exact: true }).selectOption(text(variant.interpreter)); await page.getByText('Zeitfenster und Ausführungsoptionen', { exact: true }).click();
await page.getByLabel('Exakte UTF-8 Skriptbytes', { exact: false }).fill(text(variant.script_utf8)); await page.getByLabel('Erwartete Standardausgabe (optional)').fill(params.expected_stdout == null ? '' : text(params.expected_stdout));
await page.getByLabel('Erwartete stdout-Ausgabe', { exact: false }).fill(text(params.expected_stdout)); await page.getByLabel('Laufzeit je Gerät in Sekunden').fill(String(params.timeout_seconds));
} else { await page.getByLabel('Ausgabelimit in Byte').fill(String(params.max_output_bytes));
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.
const start = new Date(Math.ceil(Date.now() / 60000) * 60000); 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('Frühester Start', { 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('Startfrist', { 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('Geräte gleichzeitig').fill('1');
await page.getByLabel('Stopp nach Fehlern', { exact: true }).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.getByLabel('Begründung', { exact: true }).fill(text(request.reason));
await page.getByRole('button', { name: 'Plan erstellen · noch keine Ausführung' }).click(); const prepared = page.waitForResponse(r => r.request().method() === 'POST' && new URL(r.url()).pathname.endsWith('/operation-plans') && r.ok());
const detail = page.locator('section[data-plan-id]'); await page.getByRole('button', { name: 'Zusammenfassung ansehen' }).click();
await detail.getByText('Technische Plandaten', { exact: true }).click(); await expect(page.getByRole('heading', { name: 'Zusammenfassung' })).toBeVisible();
await expect(detail.getByLabel('Technische Plandaten', { exact: true })).toBeVisible(); const plan = object(await (await prepared).json());
const plan = object(JSON.parse(await detail.getByLabel('Technische Plandaten', { exact: true }).innerText()));
expect(createHash('sha256').update(bytes(plan.plan_payload_bytes)).digest('hex')).toBe(plan.plan_hash); 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]'); const op = page.locator('section[data-operation-id]');
await op.getByText('Technische Auftragsdaten', { exact: true }).click(); await op.getByText('Technische Auftragsdaten', { exact: true }).click();
await expect(op.getByLabel('Technische Auftragsdaten', { exact: true })).toContainText('"job_count": 0'); 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 }); const approve = detail.getByRole('button', { name: 'SIMULIERT: Genehmigen', exact: true });
await expect(approve).toBeDisabled(); 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(); 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 expect(approve).toBeEnabled();
await approve.click(); // Deliberately no API client, injected fetch, route or direct approval request. await approve.click(); // Deliberately no API client, injected fetch, route or direct approval request.
await op.getByText('Technische Auftragsdaten', { exact: true }).click(); await op.getByText('Technische Auftragsdaten', { exact: true }).click();
+129 -37
View File
@@ -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); 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 api = '/api/v1/tenants/' + tenantId;
const permissions = [...auth.permissions, 'tenant:stop', 'system:execute']; 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[] = []; const writes: unknown[] = [];
await page.route(origin + '/auth/config', r => r.fulfill({ json: { 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 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 } }); return r.fulfill({ json: { tenant_id: tenantId, changes_stopped: stopped } });
} }
if (pathname === api + '/devices') return r.fulfill({ json: listing([windows]) }); if (pathname === api + '/devices') return r.fulfill({ json: listing([windows]) });
if (pathname === api + '/devices/' + windows.asset_id) return r.fulfill({ json: { if (pathname === api + '/script-revisions') return r.fulfill({ json: listing([
...windows, tenant_id: tenantId, { ...restart, script_sha256: hash(restart.script_utf8) }
capabilities: ready ? ['reboot', 'rmm.sync.v1', 'windows.reboot/1', 'helper.system.v1', 'system:reboot'] : [] ]) });
} }); if (req.method() !== 'GET') {
if (req.method() !== 'GET') writes.push(req.postDataJSON()); expect(req.headers()['x-csrf-token']).toBe(auth.csrf_token);
return r.fulfill({ status: 409, json: { code: 'UNSUPPORTED_CAPABILITY' } }); 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'); 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(); await expect(page.getByText('Mandantenausführung wieder zulassen', { exact: true })).toBeVisible();
expect(writes).toHaveLength(0); 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('checkbox', { name: /test-windows/ }).check();
await page.getByRole('button', { name: 'Weiter zur Aktion' }).click(); await page.getByRole('button', { name: 'Weiter zum Skript' }).click();
await page.getByRole('radio', { name: 'Gerät neu starten' }).check(); 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'); 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); expect(writes).toHaveLength(0);
ready = true; await page.getByRole('button', { name: 'Zusammenfassung ansehen' }).click();
await expect(plan).toBeEnabled({ timeout: 8000 }); await expect(page.getByRole('alert')).toContainText('Skript-Helper für SYSTEM noch nicht als betriebsbereit gemeldet');
await plan.click(); expect(writes).toEqual([{
await expect(page.getByRole('alert')).toContainText('unterstützt die ausgewählte Ausführung noch nicht'); pathname: api + '/script-revisions/' + restart.revision_id + '/plan',
expect(writes).toEqual([expect.objectContaining({ body: expect.objectContaining({
action: 'reboot', targets: { asset_ids: [windows.asset_id] }, reason: 'Neustart prüfen', targets: { asset_ids: [windows.asset_id] }, max_runtime_seconds: 120, max_output_bytes: 65536
parameters: expect.objectContaining({ execution_identity: 'system', reconnect_timeout_seconds: 180 }) })
})]); }]);
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 }) => { 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); await expect(source.getByLabel('Gespeicherter Skripttext')).toHaveCount(0);
}); });
for (const library of [true, false]) { for (const scenario of ['library', 'once', 'restart'] as const) {
test( const library = scenario !== 'once';
library const restart = scenario === 'restart';
? 'pins a revision, blocks an incompatible target and finds the submitted order after a lost response' const revision = restart ? { ...script, name: 'Linux neu starten', execution_identity: 'root', script_utf8: "printf 'Neustart-Test\n'\n" } : script;
: 'submits a one-time script without publishing a library revision', 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 }) => { async ({ page }) => {
let operationId: string | null = null; let operationId: string | null = null;
let plan: Record<string, unknown> | null = null; let plan: Record<string, unknown> | null = null;
@@ -283,7 +370,7 @@ for (const library of [true, false]) {
import React from '/node_modules/.vite/deps/react.js'; import React from '/node_modules/.vite/deps/react.js';
import ReactDOM from '/node_modules/.vite/deps/react-dom_client.js'; import ReactDOM from '/node_modules/.vite/deps/react-dom_client.js';
import {OrderComposer} from '/src/order-composer.tsx'; 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)}));
</script>` </script>`
}) })
); );
@@ -297,7 +384,7 @@ for (const library of [true, false]) {
return r.fulfill({ json: suffix.endsWith(linux.asset_id) ? linux : windows }); return r.fulfill({ json: suffix.endsWith(linux.asset_id) ? linux : windows });
if (suffix === '/script-revisions') if (suffix === '/script-revisions')
return r.fulfill({ 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) if (suffix === '/operation-plans/' + plan?.plan_id)
return r.fulfill({ json: { ...plan, operation_id: operationId } }); return r.fulfill({ json: { ...plan, operation_id: operationId } });
@@ -305,16 +392,17 @@ for (const library of [true, false]) {
posted.push(suffix); posted.push(suffix);
const body = req.postDataJSON(); const body = req.postDataJSON();
expect(req.headers()['x-csrf-token']).toBe(auth.csrf_token); 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.targets.asset_ids).toEqual([linux.asset_id]);
expect(body.reason).toBe('Abnahme'); 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 = { const action = {
action: 'run_script', action: 'run_script',
interpreter: 'posix_sh', interpreter: 'posix_sh',
script_utf8: content, script_utf8: content,
arguments: [], arguments: [],
expected_stdout: null expected_stdout: null,
...(restart ? { privileged_script_profile: 'full_maintenance_v1' } : {})
}; };
const payload = { const payload = {
schema_version: 1, schema_version: 1,
@@ -326,7 +414,7 @@ for (const library of [true, false]) {
job_id: randomUUID(), job_id: randomUUID(),
attempt_id: randomUUID(), attempt_id: randomUUID(),
action, action,
execution_identity: 'agent_service', execution_identity: revision.execution_identity,
not_before: body.schedule.not_before, not_before: body.schedule.not_before,
start_before: body.schedule.start_before, start_before: body.schedule.start_before,
max_runtime_seconds: library ? body.max_runtime_seconds : body.parameters.timeout_seconds, max_runtime_seconds: library ? body.max_runtime_seconds : body.parameters.timeout_seconds,
@@ -345,8 +433,8 @@ for (const library of [true, false]) {
...(library ...(library
? { ? {
script_revision: { script_revision: {
revision_id: script.revision_id, revision_id: revision.revision_id,
name: script.name, name: revision.name,
version: 1, version: 1,
script_sha256: job.script_sha256 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(); if (library) await page.getByRole('checkbox', { name: /test-windows/ }).check();
await page.getByRole('button', { name: 'Weiter zum Skript' }).click(); await page.getByRole('button', { name: 'Weiter zum Skript' }).click();
if (library) { 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('alert')).toContainText('test-windows');
await expect(page.getByRole('button', { name: 'Zusammenfassung ansehen' })).toBeDisabled(); await expect(page.getByRole('button', { name: 'Zusammenfassung ansehen' })).toBeDisabled();
await page.getByRole('button', { name: 'Zurück zu Geräten' }).click(); await page.getByRole('button', { name: 'Zurück zu Geräten' }).click();
await page.getByRole('checkbox', { name: /test-windows/ }).uncheck(); await page.getByRole('checkbox', { name: /test-windows/ }).uncheck();
await page.getByRole('button', { name: 'Weiter zum Skript' }).click(); 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 { } else {
await page.getByRole('radio', { name: 'Einmaliges Skript' }).check(); await page.getByRole('radio', { name: 'Einmaliges Skript' }).check();
await page.getByLabel('Skriptinhalt').fill('uname\n'); 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}$/); await expect(page.locator('body')).toHaveAttribute('data-operation', /^[a-f0-9-]{36}$/);
expect(await page.locator('body').getAttribute('data-operation')).toBe(operationId); expect(await page.locator('body').getAttribute('data-operation')).toBe(operationId);
expect(posted).toEqual([ 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' '/operation-plans/' + plan!.plan_id + '/submit'
]); ]);
expect(await page.evaluate(() => sessionStorage.length)).toBe(0); expect(await page.evaluate(() => sessionStorage.length)).toBe(0);
+14
View File
@@ -157,6 +157,20 @@ class ScriptHelperInstallation(unittest.TestCase):
self.assertIn(b'lifecycle.py run-helper',files[self.unit]) self.assertIn(b'lifecycle.py run-helper',files[self.unit])
self.assertIn(str(self.previous).encode(),self.unit.read_bytes()) 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): 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 patch.object(lifecycle.subprocess,'check_output',side_effect=subprocess.CalledProcessError(1,'verify')) as run:
with self.assertRaises(subprocess.CalledProcessError): with self.assertRaises(subprocess.CalledProcessError):
+17 -6
View File
@@ -1,4 +1,4 @@
# Linux-MVP WebUI # Rust Discovery WebUI
React/TypeScript, no runtime demo data, no desktop/PTY/hypervisor integration. React/TypeScript, no runtime demo data, no desktop/PTY/hypervisor integration.
Build assets: **`web/dist/`**; serve `index.html` and `/assets/*` from the TLS backend 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`. are relative; cookies use `credentials: same-origin`, mutations use `X-CSRF-Token`.
No token or password persistence, raw HTML rendering, automatic approval or retry. 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 ## Commands
From `web/`: `npm ci`, `npm run typecheck`, `npm test`, `npm run build`. 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. `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 The public management service is documented in [public access](../docs/public-access.md).
configured SSH tunnel and verified TLS. Earlier local `rmm-dev.internal:18443` 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 examples below are historical. The notebook is development only, without an RMM
server or enrolled agent. No certificate-verification bypass is supported. 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. `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. 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. unknown/cancellation/truncation, invalid encodings and absent/invalid results.
No browser, server, VM job, approval or deployment was executed in these checks. 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 `src/api.ts` is the sole transport/contract boundary. Responses missing required
fields fail explicitly. Unknown backend fields are displayed without interpretation. 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. success message. Tenant changes unmount all selection/plans/jobs and abort requests.
List pagination uses server cursors, without pretending a truncated page is complete. 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 `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/ API client to authorize, never writes storageState, and disables traces/screenshots/
+20 -2
View File
@@ -15,6 +15,7 @@ import {
import { AdminControl } from './management'; import { AdminControl } from './management';
import { allowed } from './safety'; import { allowed } from './safety';
import { CatalogCheckNotice } from './catalog-check'; import { CatalogCheckNotice } from './catalog-check';
import { devicePlatform } from './script-catalog';
import { ErrorBox, errorText, useResource } from './resource'; import { ErrorBox, errorText, useResource } from './resource';
import { NavIcon, orderDetailRoute } from './navigation'; import { NavIcon, orderDetailRoute } from './navigation';
import { orderTitle, Status } from './order-presentation'; import { orderTitle, Status } from './order-presentation';
@@ -115,6 +116,22 @@ function devicePath(customer: string, asset: string) {
return tenantPath(customer, '/devices/' + encodeURIComponent(asset)); 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({ function DeviceDetail({
customer, customer,
asset, asset,
@@ -158,7 +175,8 @@ function DeviceDetail({
['Speicher frei / gesamt', capacity(d.disk_free_bytes, d.disk_total_bytes)], ['Speicher frei / gesamt', capacity(d.disk_free_bytes, d.disk_total_bytes)],
['Letzter Kontakt', time(d.last_contact_at)], ['Letzter Kontakt', time(d.last_contact_at)],
['Inventar erhoben', time(d.observed_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 ( return (
<div className="device-detail"> <div className="device-detail">
@@ -654,7 +672,7 @@ export function Devices({
<button className="quiet" onClick={() => onSelection({ customer: '', ids: [] })}> <button className="quiet" onClick={() => onSelection({ customer: '', ids: [] })}>
Auswahl aufheben Auswahl aufheben
</button> </button>
<button disabled={!allowed(auth, 'operations:plan')} onClick={onCreateOrder}>Auftrag erstellen</button> <button disabled={!allowed(auth, 'operations:plan') || !allowed(auth, 'scripts:execute')} onClick={onCreateOrder}>Auftrag erstellen</button>
</div> </div>
)} )}
</> </>
+21 -60
View File
@@ -9,10 +9,10 @@ import { ScriptLibrary } from './script-library';
import { McpTokenManagement } from './mcp-token-management'; import { McpTokenManagement } from './mcp-token-management';
import React, { useEffect, useRef, useState } from 'react'; import React, { useEffect, useRef, useState } from 'react';
import { createRoot } from 'react-dom/client'; 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 './style.css';
import { AdminControl, Catalog, TenantControls } from './management'; 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 { Login } from './login';
import { ConsoleOutput, visibleControls } from './console-output'; import { ConsoleOutput, visibleControls } from './console-output';
import { scriptApprovalBlockers, scriptPlanJobs, verifyScriptPlan } from './script-console'; import { scriptApprovalBlockers, scriptPlanJobs, verifyScriptPlan } from './script-console';
@@ -53,7 +53,7 @@ export function ScriptPlanNotice({ plan }: { plan: RecordValue }) {
return target ? deviceName(target) : j.assetId; return target ? deviceName(target) : j.assetId;
}).join(', ')}</h4>} }).join(', ')}</h4>}
<p>{job.revision ? job.revision.name+' · Version '+job.revision.version : 'Einmaliges Skript'} · {job.interpreter} · {identityName(job.identity)}</p> <p>{job.revision ? job.revision.name+' · Version '+job.revision.version : 'Einmaliges Skript'} · {job.interpreter} · {identityName(job.identity)}</p>
{job.privilegedProfile === fullMaintenanceScriptProfile && <p className="warning">{fullMaintenanceWarning}</p>} {job.privilegedProfile === fullMaintenanceScriptProfile && <p className="warning">{adminScriptWarning}</p>}
{job.identity === 'root' && job.privilegedProfile !== fullMaintenanceScriptProfile && <p className="warning">{rootWarning}</p>} {job.identity === 'root' && job.privilegedProfile !== fullMaintenanceScriptProfile && <p className="warning">{rootWarning}</p>}
{job.interpreter === 'powershell' && <p>Windows PowerShell 5.1 · {job.windowsProfile === windowsPowerShellRemoteSignedProfile ? 'RemoteSigned für diesen Prozess' : 'Richtlinie des Geräts'}</p>} {job.interpreter === 'powershell' && <p>Windows PowerShell 5.1 · {job.windowsProfile === windowsPowerShellRemoteSignedProfile ? 'RemoteSigned für diesen Prozess' : 'Richtlinie des Geräts'}</p>}
<pre aria-label="Vollständiger Skripttext">{visibleControls(job.script)}</pre> <pre aria-label="Vollständiger Skripttext">{visibleControls(job.script)}</pre>
@@ -115,41 +115,6 @@ export function QueryLogsPlanNotice({ plan }: { plan: RecordValue }) {
return <aside className="warning" aria-label="Feste Live-Logfenster"><p>UI-genehmigte Liveabfrage aus hashgeprüften gespeicherten Planbytes; kein passives Inventar, keine automatische Erhebung.</p><ul>{jobs.map((job, i) => <li key={i}>Asset: {job.assetId} · Quelle: {job.source}{job.windows ? <> · Kanal: {job.channel} · Provider: {job.provider} · agent_service</> : ' · Linux-Journal'} · UTC-Fenster: [{job.since}, {job.until}) · maximal {job.maxLines} {job.windows ? 'Events' : 'Zeilen'} · {job.outputBytes} Bytes · äußere Joblaufzeit {job.runtimeSeconds}s{job.windows && ' · inneres Abfragebudget höchstens5000ms, zwischen Win32-Aufrufen kooperativ geprüft'}</li>)}</ul><p>Grenzen, Abbruch, fehlende Rechte und Teilabdeckung bleiben sichtbar. Keine Bookmarkfortschreibung durch diesen Auftrag; die Abfrage behauptet keine vollständige Sammlung aller Systemlogs.</p></aside>; return <aside className="warning" aria-label="Feste Live-Logfenster"><p>UI-genehmigte Liveabfrage aus hashgeprüften gespeicherten Planbytes; kein passives Inventar, keine automatische Erhebung.</p><ul>{jobs.map((job, i) => <li key={i}>Asset: {job.assetId} · Quelle: {job.source}{job.windows ? <> · Kanal: {job.channel} · Provider: {job.provider} · agent_service</> : ' · Linux-Journal'} · UTC-Fenster: [{job.since}, {job.until}) · maximal {job.maxLines} {job.windows ? 'Events' : 'Zeilen'} · {job.outputBytes} Bytes · äußere Joblaufzeit {job.runtimeSeconds}s{job.windows && ' · inneres Abfragebudget höchstens5000ms, zwischen Win32-Aufrufen kooperativ geprüft'}</li>)}</ul><p>Grenzen, Abbruch, fehlende Rechte und Teilabdeckung bleiben sichtbar. Keine Bookmarkfortschreibung durch diesen Auftrag; die Abfrage behauptet keine vollständige Sammlung aller Systemlogs.</p></aside>;
} catch { return <aside role="alert" className="error">Logfenster ist nicht verifiziert oder wurde verändert. Keine Genehmigung ohne gültige gespeicherte Planbytes.</aside>; } } catch { return <aside role="alert" className="error">Logfenster ist nicht verifiziert oder wurde verändert. Keine Genehmigung ohne gültige gespeicherte Planbytes.</aside>; }
} }
const initialParameters: Record<Action, RecordValue> = {
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<Action>(initialAction), [parameters, setParameters] = useState(pretty(initialParameters[initialAction])), [error, setError] = useState<string | null>(null), [busy, setBusy] = useState(false);
const [identity, setIdentity] = useState('agent_service');
return <section><h2>Neuen unveränderlichen Plan vorbereiten</h2><p>Nur fest ausgewählte Asset-IDs. Keine Ausführung durch Planung oder Antrag; jede Aktion einschließlich Live-Inventar benötigt Genehmigung.</p>
<form onSubmit={async e => { 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); } }}>
<label>Aktion<select aria-label="Aktion" value={action} onChange={e => { const next = choices.find(a => a === e.target.value); if (next) { setAction(next); setParameters(pretty(initialParameters[next])); } }}>{choices.map(a => <option key={a} value={a}>{auth.principal.simulated ? a : actionTitle(a)}</option>)}</select></label>
{action === 'update_agent' && <p className="warning">{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.</p>}
{action === 'query_logs' && <p>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.</p>}
{action === 'apt_native_acceptance' && <p className="warning">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.</p>}
{action === 'run_script' ? <><label>Skriptplattform<select aria-label="Skriptplattform" value={scriptPlatform} onChange={e => setScriptPlatform(e.target.value)}><option value="linux">Linux</option><option value="windows">Windows</option><option value="mixed">Linux und Windows · feste Varianten</option></select></label>{scriptPlatform === 'mixed' ? <label>Exakte Plattformvarianten (JSON)<textarea aria-label="Skriptvarianten" value={mixedVariants} onChange={e => setMixedVariants(e.target.value)} rows={9} spellCheck={false}/></label> : <><label>Interpreter<select name="interpreter" key={scriptPlatform}>{scriptPlatform === 'windows' ? <option value="powershell">powershell · Windows PowerShell 5.1</option> : <><option value="posix_sh">posix_sh · /bin/sh</option><option value="bash">bash · nur mit gemeldeter Capability</option></>}</select></label><label>Exakte UTF-8 Skriptbytes (keine automatische Ergänzung)<textarea name="script" required rows={7} spellCheck={false}/></label></>}<label>Format der stdout-Nachbedingung<select name="expected_format" aria-label="Format der stdout-Nachbedingung"><option value="text">Text · Linux-Default</option><option value="json">JSON-String · explizite CRLF mit \r\n</option></select></label><label>Erwartete stdout-Ausgabe (exakte Rohbytes als UTF-8, optional)<textarea name="expected" rows={2} spellCheck={false}/></label>{scriptPlatform !== 'linux' && <p>PowerShell5.1: -NoLogo -NoProfile -NonInteractive. Einzelne neue Windowspläne binden fest RemoteSigned nur für den Jobprozess. Bei gemischten Varianten ist powershell_51_remote_signed ausdrücklich an der Windowsvariante zu setzen; fehlendes Profil bleibt geerbt. Jede tatsächliche Prozessoption steht vor Genehmigung je Ziel im festen Plan. Nicht-ASCII benötigt ein ausdrücklich enthaltenes UTF-8-BOM vor Hashbildung. Skriptbytes und Ausgabe werden nicht normalisiert. Fehlende Plattform-/Interpreter-/Sync-Capability sperrt den ganzen Plan; kein stiller Zielausschluss.</p>}</> : <label>Typisierte Aktionsparameter (JSON; leere Pflichtwerte ergänzen)<textarea aria-label="Aktionsparameter" value={parameters} onChange={e => setParameters(e.target.value)} rows={9} spellCheck={false}/></label>}
<div className="grid"><label>Ausführungsidentität<select aria-label="Ausführungsidentität" name="identity" value={identity} onChange={e => setIdentity(e.target.value)}><option value="agent_service">agent_service</option><option value="root" disabled={!allowed(auth, 'root:execute')}>root · root:execute und unabhängiger Helper erforderlich</option><option value="system" disabled={!['set_service_state', 'ensure_package', 'run_script', 'update_agent'].includes(action) || !allowed(auth, 'system:execute')}>system · system:execute und Windows-SYSTEM-Helper erforderlich</option></select></label><label>Laufzeitlimit (s)<input name="timeout" key={action} type="number" min="1" max="86400" defaultValue={action === 'update_agent' ? '600' : '60'} required/></label><label>Ausgabelimit (Bytes)<input name="output" type="number" min="1" max="524288" defaultValue="65536" required/></label><label>Frühester Start (lokale Zeit)<input name="not_before" type="datetime-local" defaultValue={localDate(new Date())} required/></label><label>Startfrist / Ablauf (lokale Zeit)<input name="expires" type="datetime-local" defaultValue={localDate(new Date(Date.now() + 86400000))} required/></label><label>Maximal parallel<input name="parallel" type="number" min="1" defaultValue="1" required/></label><label>Stopp nach Fehlern<input name="failures" type="number" min="1" defaultValue="1" required/></label></div>
{action === 'run_script' && <><label>Privilegiertes Skriptprofil<select name="privileged_script_profile" aria-label="Privilegiertes Skriptprofil" key={identity} defaultValue=""><option value="">Bestehendes begrenztes Profil · keine volle Hostwartung</option><option value={fullMaintenanceScriptProfile} disabled={!['root', 'system'].includes(identity) || !allowed(auth, 'scripts:execute')}>full_maintenance_v1 · volle Hostautorität als root/SYSTEM</option></select></label><p className="warning">{fullMaintenanceWarning}</p><p>Die Auswahl erteilt keine Rechte und aktiviert keinen Client. Zentrale und lokale Policy, tatsächliche Zielcapabilities und die spätere Genehmigung werden unabhängig geprüft. SYSTEM erfordert dieses Profil; es gibt keinen automatischen Fallback.</p></>}
{identity === 'root' && !['run_script', 'update_agent'].includes(action) && <p className="warning">{rootWarning}</p>}
{identity === 'system' && !['run_script', 'update_agent'].includes(action) && <p className="warning">{systemWarning}</p>}
{identity === 'system' && action === 'ensure_package' && <p>MSI: provider=msi, package=rmm-windows-msi-fixture, architecture=x64, installation_context=machine, recipe_version=1 und vollständiges windows_msi_manifest aus dem getrennten MSI-Katalog. Genau zwei eigene Rezepte1.0/1.0→1.1;10–120s,1024–65536Bytes. APT-Manifest fehlt/null. Rezept-/Artefakthash und feste Nachbedingungen werden geprüft. Kein zusätzlicher Artefaktvektor.</p>}
{['ensure_package', 'apply_updates', 'apt_native_acceptance'].includes(action) && <details open><summary>Unveränderte Parameter-/Manifestpreview: gesamte Closure, alte/neue Versionen, Origins, Archivbytes/Hashes und Bindungen</summary><pre>{parameters}</pre><p>Struktur, exakte Transaktionsbytes und Hash werden vor Planung geprüft. Diese Vorschau behauptet keine native Akzeptanz oder Bereitschaft; keine automatische Ergänzung/Reduzierung der Closure.</p></details>}
<label>Feste importierte Artefakt-IDs (optional, maximal 16)<input name="artifact_ids" disabled={action === 'update_agent' || (identity === 'system' && action === 'ensure_package')} placeholder="MSI leitet genau eine Referenz aus dem Rezept ab; sonst UUIDs, keine URL"/></label>
<label>Begründung<input name="reason" required maxLength={1024}/></label><p>Feste Ziele ({selected.length}): {selected.join(', ') || 'keine ausgewählt'}</p>{action === 'reboot' || action === 'apply_updates' || action === 'ensure_package' ? <p className="warning">Zieländerung: Testumfang separat abstimmen. Keine implizite Reboot-/Updateerlaubnis. Neue Versuche und Folgejobs benötigen neue feste Pläne.</p> : null}<button disabled={busy || !selected.length}>Plan erstellen · noch keine Ausführung</button><ErrorBox error={error}/>
</form></section>;
}
function localDate(date: Date) { return new Date(date.getTime() - date.getTimezoneOffset() * 60000).toISOString().slice(0, 16); }
function WindowsMsiCatalog({ tenantId, auth }: { tenantId: string; auth: Session }) { function WindowsMsiCatalog({ tenantId, auth }: { tenantId: string; auth: Session }) {
const [source, setSource] = useState('{}'), [cursor, setCursor] = useState<string | null>(null), [revision, setRevision] = useState(0), [error, setError] = useState<string | null>(null), [busy, setBusy] = useState(false), [receipt, setReceipt] = useState<unknown>(null); const [source, setSource] = useState('{}'), [cursor, setCursor] = useState<string | null>(null), [revision, setRevision] = useState(0), [error, setError] = useState<string | null>(null), [busy, setBusy] = useState(false), [receipt, setReceipt] = useState<unknown>(null);
const list = useResource(async signal => { const list = useResource(async signal => {
@@ -233,6 +198,7 @@ function DeviceEnrollment({ tenantId, auth, customerName }: { tenantId: string;
const [enrollmentError, setEnrollmentError] = useState<string | null>(null); const [enrollmentError, setEnrollmentError] = useState<string | null>(null);
const [issuing, setIssuing] = useState(false); const [issuing, setIssuing] = useState(false);
const [copied, setCopied] = useState(false); const [copied, setCopied] = useState(false);
const [adminScripts, setAdminScripts] = useState(false);
return <section aria-label="Gerät aufnehmen"><h2>Gerät aufnehmen</h2> return <section aria-label="Gerät aufnehmen"><h2>Gerät aufnehmen</h2>
<p>Kunde <strong>{customerName}</strong> · Der Einmalcode gilt 15 Minuten.</p> <p>Kunde <strong>{customerName}</strong> · Der Einmalcode gilt 15 Minuten.</p>
<h3>Installation auf dem Zielgerät</h3> <h3>Installation auf dem Zielgerät</h3>
@@ -240,7 +206,12 @@ function DeviceEnrollment({ tenantId, auth, customerName }: { tenantId: string;
<li><strong>Linux</strong> · Installationsskript per HTTPS laden und mit Administratorrechten starten.</li> <li><strong>Linux</strong> · Installationsskript per HTTPS laden und mit Administratorrechten starten.</li>
<li><strong>Windows</strong> · Installationsskript per HTTPS laden und in einer administrativen PowerShell starten.</li> <li><strong>Windows</strong> · Installationsskript per HTTPS laden und in einer administrativen PowerShell starten.</li>
</ul> </ul>
<p>Die passenden Befehle erscheinen mit dem Einmalcode. Das Skript fragt den Code auf dem Zielgerät ab.</p> <label className="check"><input type="checkbox" checked={adminScripts} onChange={e => setAdminScripts(e.target.checked)}/>
Installationsbefehle für Administratorskripte anzeigen
</label>
{adminScripts && <p>Der lokale Installer aktiviert mit <code>--enable-admin-scripts</code> unter Linux oder <code>-EnableAdministratorScripts</code> unter Windows den Skript-Helper.
{' '}Für jeden Auftrag gelten zusätzlich die Skript- und Administratorrechte des Kunden und die Genehmigung in der WebUI.</p>}
<p>Die passenden Befehle erscheinen mit dem Einmalcode. Geben Sie den Code bei der Abfrage auf dem Zielgerät ein.</p>
<button disabled={issuing || !allowed(auth, 'devices:enroll')} onClick={async () => { <button disabled={issuing || !allowed(auth, 'devices:enroll')} onClick={async () => {
setIssuing(true); setEnrollment(null); setEnrollmentError(null); setCopied(false); setIssuing(true); setEnrollment(null); setEnrollmentError(null); setCopied(false);
try { try {
@@ -258,11 +229,11 @@ function DeviceEnrollment({ tenantId, auth, customerName }: { tenantId: string;
}}>Einmalcode kopieren</button> }}>Einmalcode kopieren</button>
<button className="quiet" onClick={() => { setEnrollment(null); setCopied(false); }}>Code ausblenden</button> <button className="quiet" onClick={() => { setEnrollment(null); setCopied(false); }}>Code ausblenden</button>
{copied && <p role="status">Einmalcode wurde kopiert.</p>} {copied && <p role="status">Einmalcode wurde kopiert.</p>}
{enrollment.origin && enrollment.platforms.includes('x86_64-unknown-linux-gnu') && <><p>Linux, mit einem Administratorkonto ausführen</p><pre>{`curl --fail --show-error --silent '${enrollment.origin}/install/linux.sh' -o linux.sh && sudo sh linux.sh '${enrollment.origin}'`}</pre></>} {enrollment.origin && enrollment.platforms.includes('x86_64-unknown-linux-gnu') && <><p>Linux, mit einem Administratorkonto ausführen</p><pre>{`curl --fail --show-error --silent '${enrollment.origin}/install/linux.sh' -o linux.sh && sudo sh linux.sh '${enrollment.origin}'${adminScripts ? ' --enable-admin-scripts' : ''}`}</pre></>}
{enrollment.origin && ['x86_64-pc-windows-gnu','x86_64-pc-windows-msvc'].filter(p => enrollment.platforms.includes(p)).map(platform => {enrollment.origin && ['x86_64-pc-windows-gnu','x86_64-pc-windows-msvc'].filter(p => enrollment.platforms.includes(p)).map(platform =>
<div key={platform}><p>Windows {platform.endsWith('-gnu') ? 'x64 (GNU)' : 'x64 (MSVC)'}, in einer administrativen Windows PowerShell ausführen</p> <div key={platform}><p>Windows {platform.endsWith('-gnu') ? 'x64 (GNU)' : 'x64 (MSVC)'}, in einer administrativen Windows PowerShell ausführen</p>
<pre>{`Invoke-WebRequest -UseBasicParsing '${enrollment.origin}/install/windows.ps1' -OutFile .\\windows.ps1 <pre>{`Invoke-WebRequest -UseBasicParsing '${enrollment.origin}/install/windows.ps1' -OutFile .\\windows.ps1
.\\windows.ps1 -BootstrapBase '${enrollment.origin}' -Platform '${platform}'`}</pre></div>)} .\\windows.ps1 -BootstrapBase '${enrollment.origin}' -Platform '${platform}'${adminScripts ? ' -EnableAdministratorScripts' : ''}`}</pre></div>)}
</>} </>}
</section>; </section>;
@@ -305,7 +276,9 @@ function PlanDetail({ tenantId, id, auth, onOperation, customerName, mode = 'rev
const revision = saved.script_revision ? record(saved.script_revision) : null; const revision = saved.script_revision ? record(saved.script_revision) : null;
const title = revision ? display(revision.name) : actionTitle(first && record(first.action).action); const title = revision ? display(revision.name) : actionTitle(first && record(first.action).action);
const script = first && record(first.action).action === 'run_script'; const script = first && record(first.action).action === 'run_script';
const allScripts = payloads.length > 0 && payloads.every(p => record(p.action).action === 'run_script');
const blockers = reviewBlockers(data); const blockers = reviewBlockers(data);
if (!allScripts) blockers.push('Dieser Plan enthält eine frühere Aktionsart. Erstellen Sie für die Ausführung einen neuen Skriptauftrag.');
const pending = data.approval_state === 'pending_approval'; const pending = data.approval_state === 'pending_approval';
const planHash = stringField(data,'plan_hash'); const planHash = stringField(data,'plan_hash');
const confirmed = confirmedHash === planHash; const confirmed = confirmedHash === planHash;
@@ -324,12 +297,13 @@ function PlanDetail({ tenantId, id, auth, onOperation, customerName, mode = 'rev
try { try {
await verifyReview(data, tenantId, id); await verifyReview(data, tenantId, id);
if (decision !== 'reject') { if (decision !== 'reject') {
if (!allScripts) throw new Error('Neue Geräteaufträge führen ausschließlich Skripte aus.');
const problems = reviewBlockers(data); const problems = reviewBlockers(data);
if (problems.length) throw new Error(problems.join(' · ')); if (problems.length) throw new Error(problems.join(' · '));
} }
if (decision === 'submit' && (mode !== 'submit' || !allowed(auth,'operations:submit'))) throw new Error('Einreichung nicht erlaubt.'); if (decision === 'submit' && (mode !== 'submit' || !allowed(auth,'operations:submit'))) throw new Error('Einreichung nicht erlaubt.');
if (decision !== 'submit' && (!mayDecide || !confirmed)) throw new Error('Prüfung und Berechtigung erforderlich.'); if (decision !== 'submit' && (!mayDecide || !confirmed)) throw new Error('Prüfung und Berechtigung erforderlich.');
if (decision === 'approve' && missingRights.length) throw new Error('Erforderliche Ausführungsrechte fehlen.'); if (decision !== 'reject' && missingRights.length) throw new Error('Erforderliche Ausführungsrechte fehlen.');
const submit = decision === 'submit'; const submit = decision === 'submit';
const result = record(await request(path + (submit ? '/submit' : '/authorizations'), { const result = record(await request(path + (submit ? '/submit' : '/authorizations'), {
csrf: auth.csrf_token, body: submit ? { idempotency_key: 'web-plan-' + id } : { plan_hash: planHash, decision } csrf: auth.csrf_token, body: submit ? { idempotency_key: 'web-plan-' + id } : { plan_hash: planHash, decision }
@@ -377,8 +351,9 @@ function PlanDetail({ tenantId, id, auth, onOperation, customerName, mode = 'rev
<JsonView value={data} label="Technische Plandaten"/> <JsonView value={data} label="Technische Plandaten"/>
<ErrorBox error={error ?? plan.error}/> <ErrorBox error={error ?? plan.error}/>
{(pending || mode === 'submit') && blockers.length > 0 && <p role="alert" className="error">{blockers.join(' · ')}</p>} {(pending || mode === 'submit') && blockers.length > 0 && <p role="alert" className="error">{blockers.join(' · ')}</p>}
{mode === 'submit' && !data.approval_state && missingRights.length > 0 && <p className="warning">Für die Einreichung fehlen Rechte: {missingRights.join(', ')}.</p>}
{mode === 'submit' && !data.approval_state && allowed(auth, 'operations:submit') && {mode === 'submit' && !data.approval_state && allowed(auth, 'operations:submit') &&
<button className="primary" disabled={busy || !!plan.error || !!blockers.length} onClick={() => void act('submit')}>Zur Genehmigung einreichen</button>} <button className="primary" disabled={busy || !!plan.error || !!blockers.length || !!missingRights.length} onClick={() => void act('submit')}>Zur Genehmigung einreichen</button>}
{mode === 'submit' && typeof data.operation_id === 'string' && <button className="quiet" onClick={() => onOperation(objectId(data, 'operation'))}>Eingereichten Auftrag öffnen</button>} {mode === 'submit' && typeof data.operation_id === 'string' && <button className="quiet" onClick={() => onOperation(objectId(data, 'operation'))}>Eingereichten Auftrag öffnen</button>}
{mayDecide && <fieldset disabled={busy || !!plan.error}><legend>Entscheidung</legend> {mayDecide && <fieldset disabled={busy || !!plan.error}><legend>Entscheidung</legend>
{!!missingRights.length && <p className="warning">Für die Genehmigung fehlen Rechte: {missingRights.join(', ')}.</p>} {!!missingRights.length && <p className="warning">Für die Genehmigung fehlen Rechte: {missingRights.join(', ')}.</p>}
@@ -684,9 +659,6 @@ function Workspace({ auth, logout }: { auth: Session; logout: () => void }) {
switchCustomer(tenantId); switchCustomer(tenantId);
go('genehmigungen', `pruefen/${tenantId}/${id}`); go('genehmigungen', `pruefen/${tenantId}/${id}`);
} }
function showDraft(id: string) {
go('auftraege', `entwurf/${customer}/${id}`);
}
function afterSubmission(id: string) { function afterSubmission(id: string) {
refreshInbox(value => value + 1); refreshInbox(value => value + 1);
openOperation(customer, id); openOperation(customer, id);
@@ -822,16 +794,9 @@ function Workspace({ auth, logout }: { auth: Session; logout: () => void }) {
</> : <><div className="page-title"><h1>Genehmigungen</h1></div><ApprovalInbox ownId={auth.principal.id} open={openReview} /></> </> : <><div className="page-title"><h1>Genehmigungen</h1></div><ApprovalInbox ownId={auth.principal.id} open={openReview} /></>
)} )}
{route.page === 'auftraege' && ( {route.page === 'auftraege' && (
route.tab === 'neu' ? <> (route.tab === 'neu' || route.tab === 'wartung') ? <>
<a href="#auftraege" className="back-link">← Zu den Aufträgen</a> <a href="#auftraege" className="back-link">← Zu den Aufträgen</a>
<OrderComposer tenantId={customer} customerName={customerName} auth={scoped} initialAssetIds={selected} onSubmitted={afterSubmission} onDraft={showDraft} /> <OrderComposer tenantId={customer} customerName={customerName} auth={scoped} initialAssetIds={selected} onSubmitted={afterSubmission} />
</> : route.tab === 'wartung' ? <>
<a href="#verwaltung/kataloge" className="back-link">← Zur erweiterten Verwaltung</a>
<div className="page-title"><h1>Wartungsauftrag planen</h1></div>
{allowed(scoped, 'operations:plan') ? <>
<a className="quiet" href="#geraete">Geräte auswählen</a>
<Planner tenantId={customer} auth={scoped} selected={selected} showPlan={showDraft} />
</> : <p>Die Berechtigung zum Planen von Aufträgen fehlt.</p>}
</> : detailRoute && detailId ? <> </> : detailRoute && detailId ? <>
<a href="#auftraege" className="back-link">← Zu den Aufträgen</a> <a href="#auftraege" className="back-link">← Zu den Aufträgen</a>
{detailKind === 'entwurf' ? {detailKind === 'entwurf' ?
@@ -841,7 +806,7 @@ function Workspace({ auth, logout }: { auth: Session; logout: () => void }) {
customerName={customerName} openPlan={id => openReview(customer,id)} />} customerName={customerName} openPlan={id => openReview(customer,id)} />}
</> : <> </> : <>
<div className="page-title"><h1>Aufträge</h1> <div className="page-title"><h1>Aufträge</h1>
{allowed(scoped, 'operations:plan') && <a className="primary-action" href="#auftraege/neu"><NavIcon name="plus" /> Neuer Auftrag</a>} {allowed(scoped, 'operations:plan') && allowed(scoped, 'scripts:execute') && <a className="primary-action" href="#auftraege/neu"><NavIcon name="plus" /> Neuer Auftrag</a>}
</div> </div>
<Operations tenantId={customer} customerName={customerName} open={id => openOperation(customer,id)} <Operations tenantId={customer} customerName={customerName} open={id => openOperation(customer,id)}
filters={orderFilters} apply={setOrderFilters}/> filters={orderFilters} apply={setOrderFilters}/>
@@ -868,10 +833,6 @@ function Workspace({ auth, logout }: { auth: Session; logout: () => void }) {
{adminTab === 'releases' && <AgentReleaseCatalog tenantId={customer} auth={scoped} />} {adminTab === 'releases' && <AgentReleaseCatalog tenantId={customer} auth={scoped} />}
{adminTab === 'kataloge' && ( {adminTab === 'kataloge' && (
<> <>
{allowed(scoped, 'operations:plan') && <section>
<h2>Erweiterte Wartung</h2>
<a className="quiet" href="#auftraege/wartung">Wartungsauftrag planen</a>
</section>}
<Catalog tenantId={customer} auth={scoped} /> <Catalog tenantId={customer} auth={scoped} />
<WindowsMsiCatalog tenantId={customer} auth={scoped} /> <WindowsMsiCatalog tenantId={customer} auth={scoped} />
</> </>
+1 -1
View File
@@ -197,7 +197,7 @@ function TokenManagement({ auth, tenantId }: { auth: Session; tenantId: string }
const visibleTokens = listing?.tokens.filter(token => (token.revoked_at !== null || Date.parse(token.expires_at) <= now) === history) ?? []; const visibleTokens = listing?.tokens.filter(token => (token.revoked_at !== null || Date.parse(token.expires_at) <= now) === history) ?? [];
return <section aria-label="MCP-Tokens"> return <section aria-label="MCP-Tokens">
<h2>MCP-Tokens</h2> <h2>MCP-Tokens</h2>
<p>Erstellen Sie einen Zugang für Ihren MCP-Client. Skript- und Wartungsaufträge benötigen weiterhin die Genehmigung in der WebUI.</p> <p>Erstellen Sie einen Zugang für Ihren MCP-Client. Jeder Skriptauftrag benötigt eine Genehmigung in der WebUI.</p>
<p><code>{endpoint}</code>{' '} <p><code>{endpoint}</code>{' '}
<button className="quiet" type="button" onClick={async () => { <button className="quiet" type="button" onClick={async () => {
try { await navigator.clipboard.writeText(endpoint); setNotice('MCP-Adresse wurde kopiert.'); } try { await navigator.clipboard.writeText(endpoint); setNotice('MCP-Adresse wurde kopiert.'); }
+86 -148
View File
@@ -38,7 +38,6 @@ type Props = {
auth: Session; auth: Session;
initialAssetIds: string[]; initialAssetIds: string[];
onSubmitted: (operationId: string) => void; onSubmitted: (operationId: string) => void;
onDraft: (planId: string) => void;
}; };
type Target = { type Target = {
id: string; id: string;
@@ -112,16 +111,21 @@ function blockers(review: Review) {
...scriptApprovalBlockers(review.plan) ...scriptApprovalBlockers(review.plan)
]; ];
} }
function issueMessage(err: unknown) { function issueMessage(err: unknown, identity?: string) {
if (err instanceof ApiError) { if (err instanceof ApiError) {
if (err.code === 'SCRIPT_HELPER_SCOPE_DENIED') return errorText(err);
if (err.status === 403) return 'Für diese Aktion oder die angeforderten Ausführungsrechte fehlt die Berechtigung.'; if (err.status === 403) return 'Für diese Aktion oder die angeforderten Ausführungsrechte fehlt die Berechtigung.';
if (err.code === 'SCRIPT_VARIANT_UNAVAILABLE' || err.code.includes('CAPABILITY')) if (err.code === 'SCRIPT_VARIANT_UNAVAILABLE') return 'Für mindestens eines der Zielgeräte fehlt die passende Skriptplattform.';
return 'Mindestens ein Zielgerät unterstützt die ausgewählte Ausführung noch nicht. ' + err.code; if (err.code === 'UNSUPPORTED_CAPABILITY') {
if (identity === 'system' || identity === 'root')
return 'Mindestens ein Zielgerät hat seinen Skript-Helper für ' + identityNames[identity] + ' noch nicht als betriebsbereit gemeldet.';
return 'Mindestens ein Zielgerät hat die benötigte Skriptausführung noch nicht als betriebsbereit gemeldet.';
}
} }
return errorText(err); return errorText(err);
} }
export function OrderComposer({ tenantId, auth, initialAssetIds, onSubmitted, onDraft, customerName }: Props) { export function OrderComposer({ tenantId, auth, initialAssetIds, onSubmitted, customerName }: Props) {
const path = (suffix: string) => tenantPath(tenantId, suffix); const path = (suffix: string) => tenantPath(tenantId, suffix);
const key = 'rmm:order-plan:' + JSON.stringify([auth.principal.id, tenantId]); const key = 'rmm:order-plan:' + JSON.stringify([auth.principal.id, tenantId]);
const [savedTicket, setTicket] = useState<Ticket | null>(() => resumeTicket(key)); const [savedTicket, setTicket] = useState<Ticket | null>(() => resumeTicket(key));
@@ -131,12 +135,10 @@ export function OrderComposer({ tenantId, auth, initialAssetIds, onSubmitted, on
const [query, setQuery] = useState(''); const [query, setQuery] = useState('');
const [cursor, setCursor] = useState<string | null>(null); const [cursor, setCursor] = useState<string | null>(null);
const [prior, setPrior] = useState<(string | null)[]>([]); const [prior, setPrior] = useState<(string | null)[]>([]);
const canCreate = ['inventory:read', 'operations:read', 'operations:plan', 'operations:submit'] const canPlan = ['inventory:read', 'operations:read', 'operations:plan', 'operations:submit', 'scripts:execute']
.every((permission) => allowed(auth, permission)); .every((permission) => allowed(auth, permission));
const canPlanScript = canCreate && allowed(auth, 'scripts:execute'); const ticket = canPlan ? savedTicket : null;
const canPlanReboot = canCreate && (allowed(auth, 'root:execute') || allowed(auth, 'system:execute')); const [mode, setMode] = useState<'library' | 'once'>('library');
const ticket = canPlanScript ? savedTicket : null;
const [mode, setMode] = useState<'library' | 'once' | 'reboot'>(() => canPlanScript ? 'library' : 'reboot');
const [revisionId, choose] = useState(''); const [revisionId, choose] = useState('');
const [libraryIdentity, setLibraryIdentity] = useState<Identity | null>(null); const [libraryIdentity, setLibraryIdentity] = useState<Identity | null>(null);
const [linux, setLinux] = useState<Script>(() => emptyScript('posix_sh')); const [linux, setLinux] = useState<Script>(() => emptyScript('posix_sh'));
@@ -160,7 +162,6 @@ export function OrderComposer({ tenantId, auth, initialAssetIds, onSubmitted, on
mounted.current = false; mounted.current = false;
}; };
}, []); }, []);
const canPlan = canPlanScript || canPlanReboot;
const devices = useResource( const devices = useResource(
async (signal) => { async (signal) => {
@@ -175,7 +176,7 @@ export function OrderComposer({ tenantId, auth, initialAssetIds, onSubmitted, on
); );
const review = useResource( const review = useResource(
async (signal) => { async (signal) => {
if (!ticket || !canPlanScript) return null; if (!ticket || !canPlan) return null;
const checked = await verifiedScriptOrder( const checked = await verifiedScriptOrder(
await request(path('/operation-plans/' + ticket.id), { signal }), await request(path('/operation-plans/' + ticket.id), { signal }),
tenantId, tenantId,
@@ -185,7 +186,7 @@ export function OrderComposer({ tenantId, auth, initialAssetIds, onSubmitted, on
throw Error('Der gespeicherte Plan entspricht nicht dem ausgewählten Auftrag.'); throw Error('Der gespeicherte Plan entspricht nicht dem ausgewählten Auftrag.');
return checked; return checked;
}, },
[tenantId, ticket?.id, ticket?.hash, auth.principal.id, canPlanScript] [tenantId, ticket?.id, ticket?.hash, auth.principal.id, canPlan]
); );
const missingIds = (review.data?.jobs.map((job) => job.assetId) ?? initialAssetIds).filter((id) => !known[id]); const missingIds = (review.data?.jobs.map((job) => job.assetId) ?? initialAssetIds).filter((id) => !known[id]);
const restored = useResource( const restored = useResource(
@@ -217,29 +218,20 @@ export function OrderComposer({ tenantId, auth, initialAssetIds, onSubmitted, on
const hasLinux = targets.some((d) => d?.platform === 'linux'); const hasLinux = targets.some((d) => d?.platform === 'linux');
const hasWindows = targets.some((d) => d?.platform === 'windows'); const hasWindows = targets.some((d) => d?.platform === 'windows');
const scripts = useResource( const scripts = useResource(
(signal) => (canPlanScript && step === 2 && !ticket && mode === 'library' ? loadRevisions(tenantId, signal) : Promise.resolve([])), (signal) => (canPlan && step === 2 && !ticket && mode === 'library' ? loadRevisions(tenantId, signal) : Promise.resolve([])),
[tenantId, canPlanScript, step, !!ticket, mode] [tenantId, canPlan, step, !!ticket, mode]
); );
const revision = scripts.data?.find((r) => r.revision_id === revisionId); const revision = scripts.data?.find((r) => r.revision_id === revisionId);
const heads = latestRevisions(scripts.data ?? []); const heads = latestRevisions(scripts.data ?? []);
const identity = mode === 'library' const identity = mode === 'library'
? libraryIdentity ?? revision?.execution_identity ? libraryIdentity ?? revision?.execution_identity
: (hasWindows ? windows : linux).execution_identity; : (hasWindows ? windows : linux).execution_identity;
const rebootIdentity = hasWindows ? 'system' : 'root'; const restartPlatform = hasLinux === hasWindows ? null : hasWindows ? 'windows' : 'linux';
const rebootAsset = mode === 'reboot' && step === 2 && selected.length === 1 ? selected[0] : null; const restartScript = restartPlatform && heads.find(revision =>
const rebootTarget = useResource(async signal => { revision.name === (hasWindows ? 'Windows neu starten' : 'Linux neu starten') &&
if (!rebootAsset || !canPlanReboot) return null; scriptPlatform(revision.interpreter) === restartPlatform &&
const device = record(await request(path('/devices/' + encodeURIComponent(rebootAsset)), { signal })); revision.execution_identity === (hasWindows ? 'system' : 'root')
if (device.tenant_id !== tenantId || device.asset_id !== rebootAsset || device.lifecycle !== 'current' || );
devicePlatform(device) !== (hasWindows ? 'windows' : 'linux')) {
throw Error('Das Zielgerät hat sich geändert. Wählen Sie es erneut aus.');
}
const capabilities = Array.isArray(device.capabilities) ? device.capabilities : [];
const required = hasWindows
? ['reboot', 'rmm.sync.v1', 'windows.reboot/1', 'helper.system.v1', 'system:reboot']
: ['reboot', 'rmm.sync.v1', 'helper.root.v1', 'root:reboot'];
return { agentId: objectId(device, 'agent'), ready: required.every(capability => capabilities.includes(capability)) };
}, [tenantId, rebootAsset, rebootIdentity, canPlanReboot], !!rebootAsset && canPlanReboot);
const issues: string[] = []; const issues: string[] = [];
if (targets.some((d) => !d?.current)) if (targets.some((d) => !d?.current))
issues.push('Ein Zielgerät fehlt im aktuellen Bestand. Entfernen Sie es aus der Auswahl.'); issues.push('Ein Zielgerät fehlt im aktuellen Bestand. Entfernen Sie es aus der Auswahl.');
@@ -255,13 +247,6 @@ export function OrderComposer({ tenantId, auth, initialAssetIds, onSubmitted, on
if (identity && identity !== 'agent_service' && !allowed(auth, identity + ':execute')) if (identity && identity !== 'agent_service' && !allowed(auth, identity + ':execute'))
issues.push('Die Berechtigung für ' + identityNames[identity] + ' fehlt.'); issues.push('Die Berechtigung für ' + identityNames[identity] + ' fehlt.');
} }
if (mode === 'reboot') {
if (selected.length !== 1) issues.push('Wählen Sie ein einzelnes Gerät für den Neustart.');
if (!allowed(auth, rebootIdentity + ':execute')) issues.push('Die Berechtigung für ' + identityNames[rebootIdentity] + ' fehlt.');
if (rebootTarget.error) issues.push(issueMessage(rebootTarget.error));
else if (rebootAsset && !rebootTarget.data) issues.push('Die Neustartfähigkeit des Geräts wird geprüft.');
else if (rebootTarget.data?.ready === false) issues.push('Das Zielgerät meldet derzeit keine Neustartfähigkeit für ' + identityNames[rebootIdentity] + '.');
}
if ( if (
mode === 'once' && mode === 'once' &&
hasLinux && hasLinux &&
@@ -298,7 +283,7 @@ export function OrderComposer({ tenantId, auth, initialAssetIds, onSubmitted, on
} }
async function prepare(e: FormEvent) { async function prepare(e: FormEvent) {
e.preventDefault(); e.preventDefault();
if (lock.current || !(mode === 'reboot' ? canPlanReboot : canPlanScript) || issues.length || !selected.length) return; if (lock.current || !canPlan || issues.length || !selected.length) return;
lock.current = true; lock.current = true;
setBusy(true); setBusy(true);
setError(null); setError(null);
@@ -308,48 +293,6 @@ export function OrderComposer({ tenantId, auth, initialAssetIds, onSubmitted, on
throw Error('Die Startfrist muss nach dem frühesten Start und in der Zukunft liegen.'); throw Error('Die Startfrist muss nach dem frühesten Start und in der Zukunft liegen.');
const rollout = { max_parallel: parallel, halt_after_failures: halt }; const rollout = { max_parallel: parallel, halt_after_failures: halt };
const bound = { targets: { asset_ids: selected }, rollout, reason: reason.trim() }; const bound = { targets: { asset_ids: selected }, rollout, reason: reason.trim() };
if (mode === 'reboot') {
const input: PlanInput = {
...bound,
tenant_id: tenantId,
action: 'reboot',
schedule: { ...schedule, offline_policy: 'wait_until_deadline' },
rollout: { max_parallel: 1, halt_after_failures: 1 },
parameters: {
execution_identity: rebootIdentity,
reason: bound.reason,
dependency_group: 'asset-' + selected[0],
reconnect_timeout_seconds: hasWindows ? 180 : 300,
timeout_seconds: 60,
max_output_bytes: 4096
}
};
validateInput(input);
await validateSensitiveInput(input, auth);
const plan = record(await request(path('/operation-plans'), { csrf: auth.csrf_token, body: input }));
if (!Array.isArray(plan.plan_payload_bytes)) throw Error('Die gespeicherten Bytes des Neustartplans fehlen.');
await verifyPlanIntegrity(plan);
const planId = objectId(plan, 'plan');
const fixed = record(plan.plan_payload);
const jobs = Array.isArray(fixed.jobs) ? fixed.jobs : [];
const job = record(record(jobs[0]).payload);
const action = record(job.action);
if (
fixed.plan_id !== planId || fixed.tenant_id !== tenantId || fixed.principal !== auth.principal.id ||
fixed.reason !== bound.reason || fixed.max_parallel !== 1 || fixed.halt_after_failures !== 1 ||
jobs.length !== 1 || job.asset_id !== selected[0] || job.agent_id !== rebootTarget.data?.agentId ||
job.execution_identity !== rebootIdentity ||
action.action !== 'reboot' || action.reason !== bound.reason ||
action.dependency_group !== input.parameters.dependency_group ||
action.reconnect_timeout_seconds !== input.parameters.reconnect_timeout_seconds ||
job.max_runtime_seconds !== input.parameters.timeout_seconds ||
job.max_output_bytes !== input.parameters.max_output_bytes ||
Date.parse(String(job.not_before)) !== Date.parse(schedule.not_before) ||
Date.parse(String(job.start_before)) !== Date.parse(schedule.start_before)
) throw Error('Der erstellte Neustartplan weicht von diesem Entwurf ab.');
if (mounted.current) onDraft(planId);
return;
}
let raw: unknown; let raw: unknown;
if (mode === 'library') { if (mode === 'library') {
if (!revision) throw Error('Wählen Sie eine Skriptversion.'); if (!revision) throw Error('Wählen Sie eine Skriptversion.');
@@ -426,14 +369,14 @@ export function OrderComposer({ tenantId, auth, initialAssetIds, onSubmitted, on
if (mounted.current) if (mounted.current)
saveTicket({ id: objectId(checked.plan, 'plan'), hash: String(checked.plan.plan_hash), attempted: false }); saveTicket({ id: objectId(checked.plan, 'plan'), hash: String(checked.plan.plan_hash), attempted: false });
} catch (e) { } catch (e) {
if (mounted.current) setError(issueMessage(e)); if (mounted.current) setError(issueMessage(e, identity));
} finally { } finally {
lock.current = false; lock.current = false;
if (mounted.current) setBusy(false); if (mounted.current) setBusy(false);
} }
} }
async function submit() { async function submit() {
if (!ticket || !review.data || !canPlanScript || lock.current) return; if (!ticket || !review.data || !canPlan || lock.current) return;
lock.current = true; lock.current = true;
setBusy(true); setBusy(true);
setError(null); setError(null);
@@ -466,7 +409,7 @@ export function OrderComposer({ tenantId, auth, initialAssetIds, onSubmitted, on
if (mounted.current) { if (mounted.current) {
if (!ticket.attempted && err instanceof ApiError && err.status >= 400 && err.status < 500) if (!ticket.attempted && err instanceof ApiError && err.status >= 400 && err.status < 500)
saveTicket({ ...ticket, attempted: false }); saveTicket({ ...ticket, attempted: false });
setError(issueMessage(err)); setError(issueMessage(err, review.data?.jobs[0]?.identity));
review.reload(); review.reload();
} }
} finally { } finally {
@@ -481,7 +424,7 @@ export function OrderComposer({ tenantId, auth, initialAssetIds, onSubmitted, on
<h1>Neuer Auftrag</h1> <h1>Neuer Auftrag</h1>
</div> </div>
<ol className="order-progress" aria-label="Auftragsschritte"> <ol className="order-progress" aria-label="Auftragsschritte">
{['Geräte', 'Aktion', 'Zusammenfassung'].map((name, i) => ( {['Geräte', 'Skript', 'Zusammenfassung'].map((name, i) => (
<li key={name} aria-current={stepNumber === i + 1 ? 'step' : undefined}> <li key={name} aria-current={stepNumber === i + 1 ? 'step' : undefined}>
{i + 1}. {name} {i + 1}. {name}
</li> </li>
@@ -492,10 +435,10 @@ export function OrderComposer({ tenantId, auth, initialAssetIds, onSubmitted, on
<section> <section>
<p> <p>
Zum Erstellen eines Auftrags benötigen Sie Gerätezugriff, Rechte zum Planen und Einreichen und das Zum Erstellen eines Auftrags benötigen Sie Gerätezugriff, Rechte zum Planen und Einreichen und das
Ausführungsrecht für die gewählte Aktion. Ausführungsrecht für Skripte.
</p> </p>
</section> </section>
) : ticket && canPlanScript ? ( ) : ticket ? (
<section aria-label="Auftrag prüfen"> <section aria-label="Auftrag prüfen">
<h2>Zusammenfassung</h2> <h2>Zusammenfassung</h2>
{review.data ? ( {review.data ? (
@@ -672,7 +615,7 @@ export function OrderComposer({ tenantId, auth, initialAssetIds, onSubmitted, on
setError(null); setError(null);
}} }}
> >
{canPlanReboot ? 'Weiter zur Aktion' : 'Weiter zum Skript'} Weiter zum Skript
</button> </button>
</div> </div>
{selected.length > 100 && <p role="alert">Ein Auftrag kann bis zu 100 Geräte enthalten.</p>} {selected.length > 100 && <p role="alert">Ein Auftrag kann bis zu 100 Geräte enthalten.</p>}
@@ -680,25 +623,26 @@ export function OrderComposer({ tenantId, auth, initialAssetIds, onSubmitted, on
</section> </section>
) : ( ) : (
<section> <section>
<h2>{canPlanReboot ? 'Aktion auswählen' : 'Skript auswählen'}</h2> <h2>Skript auswählen</h2>
<form onSubmit={prepare}> <form onSubmit={prepare}>
<fieldset disabled={busy} className="work-form"> <fieldset disabled={busy} className="work-form">
<div className="order-source"> <div className="order-source">
{canPlanScript && <label> <label>
<input type="radio" name="quelle" checked={mode === 'library'} onChange={() => setMode('library')} /> <input type="radio" name="quelle" checked={mode === 'library'} onChange={() => setMode('library')} />
Aus der Bibliothek Aus der Bibliothek
</label>} </label>
{canPlanScript && <label> <label>
<input type="radio" name="quelle" checked={mode === 'once'} onChange={() => setMode('once')} /> <input type="radio" name="quelle" checked={mode === 'once'} onChange={() => setMode('once')} />
Einmaliges Skript Einmaliges Skript
</label>} </label>
{canPlanReboot && <label>
<input type="radio" name="quelle" checked={mode === 'reboot'} onChange={() => setMode('reboot')} />
Gerät neu starten
</label>}
</div> </div>
{mode === 'library' ? ( {mode === 'library' ? (
<> <>
{restartScript && allowed(auth, restartScript.execution_identity + ':execute') && (
<button type="button" className="quiet" onClick={() => chooseLibrary(restartScript)}>
Neustartskript auswählen
</button>
)}
<label> <label>
Bibliotheksskript Bibliotheksskript
<select <select
@@ -735,6 +679,7 @@ export function OrderComposer({ tenantId, auth, initialAssetIds, onSubmitted, on
</select> </select>
</label> </label>
<p>{interpreterNames[revision.interpreter]}</p> <p>{interpreterNames[revision.interpreter]}</p>
<details><summary>Skriptinhalt anzeigen</summary><pre>{revision.script_utf8}</pre></details>
<label> <label>
Ausführen als Ausführen als
<select value={identity} onChange={(e) => { <select value={identity} onChange={(e) => {
@@ -754,18 +699,13 @@ export function OrderComposer({ tenantId, auth, initialAssetIds, onSubmitted, on
</> </>
)} )}
</> </>
) : mode === 'once' ? ( ) : (
<> <>
{hasLinux && <ScriptFieldsForPlatform script={linux} change={setLinux} auth={auth} windows={false} />} {hasLinux && <ScriptFieldsForPlatform script={linux} change={setLinux} auth={auth} windows={false} />}
{hasWindows && <ScriptFieldsForPlatform script={windows} change={setWindows} auth={auth} windows />} {hasWindows && <ScriptFieldsForPlatform script={windows} change={setWindows} auth={auth} windows />}
</> </>
) : (
<p className="warning">
Der Auftrag startet das ausgewählte Gerät nach Genehmigung neu. Ausführung als {identityNames[rebootIdentity]}.
Der Agent muss nach dem Neustart wieder Kontakt aufnehmen.
</p>
)} )}
{mode !== 'reboot' && identity && identity !== 'agent_service' && ( {identity && identity !== 'agent_service' && (
<p className="warning">Der genehmigte Skriptauftrag erhält volle Hostrechte als {identityNames[identity]}.</p> <p className="warning">Der genehmigte Skriptauftrag erhält volle Hostrechte als {identityNames[identity]}.</p>
)} )}
<label> <label>
@@ -783,51 +723,49 @@ export function OrderComposer({ tenantId, auth, initialAssetIds, onSubmitted, on
Startfrist Startfrist
<input required type="datetime-local" value={end} onChange={(e) => setEnd(e.target.value)} /> <input required type="datetime-local" value={end} onChange={(e) => setEnd(e.target.value)} />
</label> </label>
{mode !== 'reboot' && <> <label>
<label> Laufzeit je Gerät in Sekunden
Laufzeit je Gerät in Sekunden <input
<input required
required type="number"
type="number" min={1}
min={1} max={maxRuntime}
max={maxRuntime} value={runtime}
value={runtime} onChange={(e) => setRuntime(Number(e.target.value))}
onChange={(e) => setRuntime(Number(e.target.value))} />
/> </label>
</label> <label>
<label> Ausgabelimit in Byte
Ausgabelimit in Byte <input
<input required
required type="number"
type="number" min={1}
min={1} max={identity === 'agent_service' ? 262144 : 65536}
max={identity === 'agent_service' ? 262144 : 65536} value={limit}
value={limit} onChange={(e) => setLimit(Number(e.target.value))}
onChange={(e) => setLimit(Number(e.target.value))} />
/> </label>
</label> <label>
<label> Geräte gleichzeitig
Geräte gleichzeitig <input
<input required
required type="number"
type="number" min={1}
min={1} max={10}
max={10} value={parallel}
value={parallel} onChange={(e) => setParallel(Number(e.target.value))}
onChange={(e) => setParallel(Number(e.target.value))} />
/> </label>
</label> <label>
<label> Stopp nach Fehlern
Stopp nach Fehlern <input
<input required
required type="number"
type="number" min={1}
min={1} value={halt}
value={halt} onChange={(e) => setHalt(Number(e.target.value))}
onChange={(e) => setHalt(Number(e.target.value))} />
/> </label>
</label>
</>}
</div> </div>
{mode === 'once' && ( {mode === 'once' && (
<> <>
+15 -2
View File
@@ -1,7 +1,20 @@
import React, { useEffect, useMemo, useState } from 'react'; import React, { useEffect, useMemo, useState } from 'react';
export const errorText = (error: unknown) => import { ApiError } from './api';
error instanceof Error ? error.message : 'Unbekannter Fehler';
export function errorText(error: unknown) {
if (error instanceof ApiError) {
if (error.code === 'SCRIPT_ACTION_REQUIRED')
return 'Diese frühere Aktionsart ist stillgelegt. Erstellen Sie einen Skriptauftrag.';
if (error.code === 'SCRIPT_HELPER_SCOPE_DENIED')
return 'Die zentrale Richtlinie erlaubt dieses Administratorskript für das gewählte Konto, Gerät oder den Skriptinhalt nicht.';
if (error.code === 'MANAGED_SCRIPT_POLICY_INVALID')
return 'Der Server konnte die hinterlegte Richtlinie für Administratorskripte nicht bestätigen.';
if (error.code === 'SCRIPT_HELPER_BINDING_INVALID')
return 'Der Server kann die gemeldete Agentversion und den zugehörigen Administrator-Helper für dieses Gerät nicht bestätigen.';
}
return error instanceof Error ? error.message : 'Unbekannter Fehler';
}
export function ErrorBox({ error }: { error: string | null }) { export function ErrorBox({ error }: { error: string | null }) {
return error ? ( return error ? (
<div role="alert" className="error"> <div role="alert" className="error">
+3 -5
View File
@@ -1,7 +1,7 @@
import { describe, expect, it, vi } from 'vitest'; import { describe, expect, it, vi } from 'vitest';
import { renderToStaticMarkup } from 'react-dom/server'; import { renderToStaticMarkup } from 'react-dom/server';
import { actions, PlanInput, Session, request, session, windowsMsi, windowsMsiManifest, validateInput } from './api'; import { PlanInput, Session, request, session, windowsMsi, windowsMsiManifest, validateInput } from './api';
import { adminIntent, allowed, availableActions, windowsMsiPlanJobs, windowsMsiApprovalBlockers, verifyWindowsMsiManifest, parseStrictJson, powerShellApprovalBlockers, powerShellPlanJobs, queryLogsApprovalBlockers, queryLogsPlanJobs, recipeInput, rootWarning, sha256, validateAptManifest, validateSensitiveInput, verifyAptManifest, verifyPlanIntegrity } from './safety'; import { adminIntent, allowed, windowsMsiPlanJobs, windowsMsiApprovalBlockers, verifyWindowsMsiManifest, parseStrictJson, powerShellApprovalBlockers, powerShellPlanJobs, queryLogsApprovalBlockers, queryLogsPlanJobs, recipeInput, rootWarning, sha256, validateAptManifest, validateSensitiveInput, verifyAptManifest, verifyPlanIntegrity } from './safety';
import { AdminControl } from './management'; import { AdminControl } from './management';
vi.mock('react-dom/client', () => ({ createRoot: () => ({ render: vi.fn() }) })); vi.mock('react-dom/client', () => ({ createRoot: () => ({ render: vi.fn() }) }));
@@ -115,9 +115,7 @@ describe('root and dedicated dev-test APT actions', () => {
await expect(verifyPlanIntegrity({ plan_payload_bytes: Array.from(shellRaw), plan_hash: await sha256(shellRaw) })).rejects.toThrow(); await expect(verifyPlanIntegrity({ plan_payload_bytes: Array.from(shellRaw), plan_hash: await sha256(shellRaw) })).rejects.toThrow();
await expect(validateSensitiveInput({ ...value, parameters: { ...value.parameters, execution_identity: 'root' } }, systemAuth)).rejects.toThrow('root:execute'); await expect(validateSensitiveInput({ ...value, parameters: { ...value.parameters, execution_identity: 'root' } }, systemAuth)).rejects.toThrow('root:execute');
}); });
it('shows native acceptance only with explicit server simulation evidence, never upgrades identity', async () => { it('validates the explicit simulation and root identity of historical native acceptance input', async () => {
expect(availableActions(auth, actions)).toContain('apt_native_acceptance');
expect(availableActions({ ...auth, principal: { ...auth.principal, simulated: false } }, actions)).not.toContain('apt_native_acceptance');
const value = input(await manifest()); const value = input(await manifest());
await validateSensitiveInput(value, auth); expect(value.parameters.execution_identity).toBe('root'); await validateSensitiveInput(value, auth); expect(value.parameters.execution_identity).toBe('root');
await expect(validateSensitiveInput({ ...value, parameters: { ...value.parameters, execution_identity: 'agent_service' } }, auth)).rejects.toThrow('root'); await expect(validateSensitiveInput({ ...value, parameters: { ...value.parameters, execution_identity: 'agent_service' } }, auth)).rejects.toThrow('root');
+2 -3
View File
@@ -1,4 +1,4 @@
import { Action, PlanInput, RecordValue, Session, planTargetPreviews, record, text, validateSystemService, validateWindowsReboot, windowsScriptProfile, logWindow, validateWindowsLogLimits, windowsEventLogFixtureSource, windowsEventLogFixtureChannel, windowsEventLogFixtureProvider, WindowsMsiManifest, MsiPostcondition, windowsMsi, windowsMsiManifest, windowsMsiAction, validateWindowsMsiInput, validateWindowsMsiLimits, msiUuid, fullMaintenanceScriptProfile, privilegedScriptProfile, validateScriptIdentityProfile } from './api'; import { PlanInput, RecordValue, Session, planTargetPreviews, record, text, validateSystemService, validateWindowsReboot, windowsScriptProfile, logWindow, validateWindowsLogLimits, windowsEventLogFixtureSource, windowsEventLogFixtureChannel, windowsEventLogFixtureProvider, WindowsMsiManifest, MsiPostcondition, windowsMsi, windowsMsiManifest, windowsMsiAction, validateWindowsMsiInput, validateWindowsMsiLimits, msiUuid, fullMaintenanceScriptProfile, privilegedScriptProfile, validateScriptIdentityProfile } from './api';
import { validateAgentUpdateAction } from './agent-updates'; import { validateAgentUpdateAction } from './agent-updates';
import { bytes, hashPattern, parseStrictJson, sha256 } from './plan-bytes'; import { bytes, hashPattern, parseStrictJson, sha256 } from './plan-bytes';
@@ -6,10 +6,9 @@ import { verifyScriptPlan } from './script-console';
export { bytes, hashPattern, parseStrictJson, sha256 } from './plan-bytes'; export { bytes, hashPattern, parseStrictJson, sha256 } from './plan-bytes';
export const rootWarning = 'HOHES RISIKO: root kann das Zielsystem verändern. Keine automatische Rechteerhöhung; eigener expliziter Plan, Scope, Helper und Genehmigung erforderlich.'; export const rootWarning = 'HOHES RISIKO: root kann das Zielsystem verändern. Keine automatische Rechteerhöhung; eigener expliziter Plan, Scope, Helper und Genehmigung erforderlich.';
export const systemWarning = 'SYSTEM: ausschließlich fest benannter Windows-Fixturedienst (running/stopped) oder eigenes festes MSI-Rezept. Eigenes system:execute, unabhängiger Helper und konkrete WebUI-Genehmigung erforderlich. Keine SYSTEM-Shell, kein impliziter Reboot oder Retry.'; export const systemWarning = 'SYSTEM: ausschließlich fest benannter Windows-Fixturedienst (running/stopped) oder eigenes festes MSI-Rezept. Eigenes system:execute, unabhängiger Helper und konkrete WebUI-Genehmigung erforderlich. Keine SYSTEM-Shell, kein impliziter Reboot oder Retry.';
export const fullMaintenanceWarning = 'VOLLE HOSTWARTUNG · full_maintenance_v1: Das genehmigte Skript läuft als root/SYSTEM mit vollständiger Hostautorität, einschließlich Netzwerk, Dateisystem und Diensten. Es kann auch Agent, PKI und Schutzmechanismen ändern oder einen Neustart auslösen. Keine Sandbox- oder No-Reboot-Zusage. scripts:execute plus root:execute/system:execute, lokaler und zentraler Opt-in, passende Capability, unabhängiger Helper und konkrete WebUI-Genehmigung bleiben erforderlich.'; export const adminScriptWarning = 'Das Skript erhält volle Administratorrechte. Es kann Dateien, Dienste, den Agenten und Gerätezertifikate ändern sowie das Gerät neu starten.';
export function permissions(auth: Session): string[] | null { return auth.permissions ?? null; } export function permissions(auth: Session): string[] | null { return auth.permissions ?? null; }
export function allowed(auth: Session, permission: string): boolean { return permissions(auth)?.includes(permission) === true; } export function allowed(auth: Session, permission: string): boolean { return permissions(auth)?.includes(permission) === true; }
export function availableActions(auth: Session, base: readonly Action[]): Action[] { return base.filter(a => a !== 'apt_native_acceptance' || auth.principal.simulated === true); }
function exact(r: RecordValue, fields: string[]) { if (Object.keys(r).some(k => !fields.includes(k)) || fields.some(k => !(k in r))) throw new Error('Schemafelder fehlen oder sind unbekannt'); } function exact(r: RecordValue, fields: string[]) { if (Object.keys(r).some(k => !fields.includes(k)) || fields.some(k => !(k in r))) throw new Error('Schemafelder fehlen oder sind unbekannt'); }
function hash(v: unknown) { if (typeof v !== 'string' || !hashPattern.test(v) || /^0{64}$/.test(v)) throw new Error('Exakter SHA-256 fehlt/Platzhalter'); } function hash(v: unknown) { if (typeof v !== 'string' || !hashPattern.test(v) || /^0{64}$/.test(v)) throw new Error('Exakter SHA-256 fehlt/Platzhalter'); }
+1 -1
View File
@@ -113,7 +113,7 @@ it('shows full fixed script/profile/identities before approval and has no approv
const p = plan('windows_system_full'); expect(renderToStaticMarkup(<ScriptPlanNotice plan={p}/>)).toContain('role="alert"'); const p = plan('windows_system_full'); expect(renderToStaticMarkup(<ScriptPlanNotice plan={p}/>)).toContain('role="alert"');
await verifyPlanIntegrity(p); await verifyScriptPlan(p); await verifyPlanIntegrity(p); await verifyScriptPlan(p);
const html = renderToStaticMarkup(<ScriptPlanNotice plan={p}/>), view = scriptPlanJobs(p)[0]!; const html = renderToStaticMarkup(<ScriptPlanNotice plan={p}/>), view = scriptPlanJobs(p)[0]!;
for (const value of ['full_maintenance_v1', 'system', 'powershell', 'RemoteSigned', 'SYSTEM stdout', 'SYSTEM stderr', '\\u000d', view.assetId, view.jobId, view.attemptId, view.scriptHash, view.jobHash, '30s', '4096', 'Keine Sandbox- oder No-Reboot-Zusage', 'Agent, PKI']) expect(html).toContain(value); for (const value of ['full_maintenance_v1', 'system', 'powershell', 'RemoteSigned', 'SYSTEM stdout', 'SYSTEM stderr', '\\u000d', view.assetId, view.jobId, view.attemptId, view.scriptHash, view.jobHash, '30s', '4096', 'volle Administratorrechte', 'Gerätezertifikate', 'das Gerät neu starten']) expect(html).toContain(value);
expect(html).not.toMatch(/<(button|input|form)\b/); expect(fetch).not.toHaveBeenCalled(); expect(html).not.toMatch(/<(button|input|form)\b/); expect(fetch).not.toHaveBeenCalled();
} finally { vi.unstubAllGlobals(); } } finally { vi.unstubAllGlobals(); }
}); });