Compare commits

..
3 Commits
12 changed files with 520 additions and 16 deletions
+2
View File
@@ -16,6 +16,8 @@ Für Geräte und Kunden gilt Kapitel 0.7. Änderungen an Kundengrenzen mit besch
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.
Für MCP-Administratoranträge gemäß Kapitel 0.12 zuerst die wirksamen Tokenrechte im Kunden und die zentrale Regel der konkreten Installation prüfen. Bei `SCRIPT_HELPER_SCOPE_DENIED` zeigt der [Operator für die Geräteregel](docs/public-access.md#administrator-skripte-anfordern), ob sie für solche Anträge geöffnet ist.
## Betrieb und Freigabe
- Der dedizierte Server ist `discovery.ease-technologies.de`. Testclients sind die Cloud-Linux-VM und der Windows-11-Gast. Das Notebook dient ausschließlich der Entwicklung. Plattformspezifische Arbeit auf beiden Gästen darf parallel laufen. Plattformfunktionen jeweils nativ nachweisen.
Generated
+1 -1
View File
@@ -2213,7 +2213,7 @@ dependencies = [
[[package]]
name = "rmm-agent-windows"
version = "0.1.15"
version = "0.1.16"
dependencies = [
"anyhow",
"base64 0.22.1",
+7 -1
View File
@@ -1,6 +1,6 @@
# Rust RMM: Architektur und Implementierungsspezifikation
Version 1.40 · 2026-11-18 · Sprache: Deutsch
Version 1.41 · 2026-11-18 · Sprache: Deutsch
**Zweck:** Vollständige, eigenständig nutzbare Grundlage für die Implementierung einer mandantenfähigen Plattform zur Inventarisierung, Überwachung und Fernadministration von Kundengeräten durch eine Coding-KI und ein Entwicklungsteam.
@@ -114,6 +114,12 @@ Minuten nach Empfang nutzbar (bisher 100 ms). Details Kapitel 0.3.
## 0 Auftrag und verbindliche Produktanforderungen
### 0.12 MCP-Anträge für Administrator-Skripte (Version 1.41)
Ein MCP-Token kann einmalige Skripte und feste Bibliotheksversionen für seine Kunden planen und einreichen. Die Rechte werden pro Token auf dem Server vergeben. Zusätzlich zu Planung, Einreichung, Lesen und Skriptausführung erfordert der administrative Kontext auf Linux `root:execute`, auf Windows `system:execute`.
Der Betreiber kann eine bestehende zentrale Geräteregel für diese Tokenrechte öffnen. Dabei gelten die Bindungen an Installation, Helper und Skriptprofil sowie etwaige Beschränkungen auf konkrete Skriptinhalte. Eine Tokenrotation erfordert auf dem Client keine Konfigurationsänderung. Der Server stellt den signierten Startauftrag nach der persönlichen Entscheidung aus Kapitel 0.8 aus. Der Client prüft dessen Bindung an Gerät, Skript und Versuch und führt ihn ohne lokale Rückfrage aus.
### 0.11 Gültigkeit von Releases bei bereits installierten Skripthelfern (Version 1.40)
Für Neuinstallationen und Updates muss das Release-Manifest zum Zeitpunkt der Prüfung gültig sein. Für Administrator-Skripte auf bereits installierten Clients prüft der Server die Manifest-Gültigkeit zum gespeicherten Zeitpunkt der Katalogregistrierung. Die Signatur wird mit dem aktuellen Schlüsselring geprüft. Gerätebindung, Helper-Hash, Berechtigungen und Auftragsgenehmigung sind weiterhin erforderlich.
+76 -1
View File
@@ -365,7 +365,6 @@ impl<V: Ed25519Verifier> ClientSync<V> {
&& original.helper_previous_decision_id == h.to_string()
&& original.previous_request_id.is_empty()
&& original.journal_complete
&& original.durable_message_ids.is_empty()
&& decision.issued_at <= now
&& decision.connection_generation <= channel.connection_generation
&& previous.connection_generation <= decision.connection_generation
@@ -379,6 +378,7 @@ impl<V: Ed25519Verifier> ClientSync<V> {
&& helper.checkpoint >= decision.helper_checkpoint,
"CLOSED_CONTROL_EXACT_PARTIAL_EDGE"
);
verify_closed_result_messages(db, &original, &decision)?;
let current = attempts(db, ledger, &self.binding)?;
ensure!(
current.len() == original.attempts.len()
@@ -1171,6 +1171,81 @@ pub fn archive_events(db: &Connection) -> Result<()> {
}
Ok(())
}
/// A partial control edge can contain the result that closed an attempt, and
/// an earlier unknown report for that same grant. Only account for archived
/// messages here. Never ACK an event, change its state or replay a result.
fn verify_closed_result_messages(
db: &Connection,
request: &SyncRequest,
decision: &ReconcileDecisionPayload,
) -> Result<()> {
for id in &request.durable_message_ids {
let raw: Vec<u8> = db.query_row(
"SELECT envelope FROM reconcile_results WHERE id=?1",
[id],
|r| r.get(0),
)?;
let envelope = Envelope::decode(raw.as_slice())?;
let Some(Payload::JobResult(result)) = &envelope.payload else {
anyhow::bail!("CLOSED_CONTROL_EXPECTED_RESULT");
};
let attempt = request
.attempts
.iter()
.find(|a| {
a.job_id == result.job_id
&& a.attempt_id == result.attempt_id
&& a.grant_id == result.grant_id
})
.context("CLOSED_CONTROL_ARCHIVED_ATTEMPT")?;
let final_envelope = attempt
.result_envelope
.as_ref()
.context("CLOSED_CONTROL_FINAL_ENVELOPE")?;
let final_id = Uuid::parse_str(&attempt.result_message_id)?;
let persisted: bool = db.query_row(
"SELECT EXISTS(SELECT 1 FROM reconcile_receipts WHERE id=?1 AND decision_id=?2)",
params![attempt.result_message_id, decision.decision_id.to_string()],
|r| r.get(0),
)?;
ensure!(
persisted
&& decision.acknowledged_message_ids.contains(&final_id)
&& request
.durable_message_ids
.contains(&attempt.result_message_id)
&& final_envelope.message_id == attempt.result_message_id
&& envelope.message_id == *id
&& envelope.encode_to_vec() == raw
&& rmm_protocol::valid_envelope(
&envelope,
&decision.agent_id.to_string(),
final_envelope.connection_generation
)
&& envelope.boot_id == final_envelope.boot_id
&& matches!(
attempt.state.as_str(),
"succeeded" | "failed" | "cancelled" | "expired"
)
&& !result.grant_id.is_empty(),
"CLOSED_CONTROL_FINAL_RESULT_RECEIPT"
);
ensure!(
if *id == attempt.result_message_id {
envelope == *final_envelope
&& result.revision == attempt.revision
&& result.state == attempt.state
&& canonical_outcome_bytes(&outcome(result)?)? == attempt.outcome_bytes
} else {
result.state == "unknown"
&& result.revision < attempt.revision
&& envelope.sequence < final_envelope.sequence
},
"CLOSED_CONTROL_CONFLICTING_ARCHIVED_RESULT"
);
}
Ok(())
}
fn pending_ids(db: &Connection) -> Result<Vec<String>> {
let mut statement = db.prepare("SELECT id,payload FROM job_events ORDER BY id")?;
let rows = statement
+97
View File
@@ -1091,6 +1091,103 @@ fn windows_unconfirmed_helper_head_cannot_replace_a_committed_decision() {
);
assert!(!reopened.can_start(&f.channel, false, &f.clock));
}
#[test]
fn missed_system_ack_after_result_delivery_requires_archived_definitive_proof() {
let mut f = Fixture::new();
f.helper_identity = HelperIdentity::System;
let mut c = f.client();
let mut helper = HelperSnapshot {
journal_id: Uuid::new_v4(),
checkpoint: 1,
previous_decision_id: None,
attempts: vec![],
};
let first = c
.prepare(
&mut f.db,
&f.ledger,
f.channel.clone(),
Some(&helper),
&f.clock,
)
.unwrap();
let anchor = f.decision(&first, true);
f.apply(&mut c, &anchor).unwrap();
c.apply_consumption(&mut f.ledger, &f.clock).unwrap();
helper.previous_decision_id = Some(anchor.decision_id);
c.confirm_helper(&helper).unwrap();
helper.checkpoint += 1;
let (offer, grant, report) = f.add("unknown", true, Some(success()), script());
let mut prior = report.unwrap();
let Some(Payload::JobResult(result)) = &mut prior.payload else {
unreachable!()
};
result.state = "unknown".into();
f.db.execute(
"UPDATE job_events SET payload=?1 WHERE id=?2",
params![prior.encode_to_vec(), prior.message_id],
)
.unwrap();
let final_report =
persist_original_fixture_result(&mut f, &offer, &grant.unwrap(), completion_outcome());
let edge = c
.prepare(
&mut f.db,
&f.ledger,
f.channel.clone(),
Some(&helper),
&f.clock,
)
.unwrap();
assert_eq!(edge.request.durable_message_ids.len(), 2);
let mut signed = f.decision(&edge, true);
signed
.acknowledged_message_ids
.push(Uuid::parse_str(&final_report.message_id).unwrap());
f.apply(&mut c, &signed).unwrap();
c.apply_consumption(&mut f.ledger, &f.clock).unwrap();
helper.checkpoint += 1;
f.channel.connection_generation += 1;
let mut fresh = f.client();
let prepare = |c: &mut ClientSync, f: &mut Fixture| {
c.prepare_with_closed_control_idle(
&mut f.db,
&f.ledger,
f.channel.clone(),
Some(&helper),
&f.clock,
true,
)
};
assert!(prepare(&mut fresh, &mut f).is_err()); // prior report still pending
rmm_agent_core::jobs::ack(&mut f.db, &prior.message_id).unwrap();
let mut conflicting = prior.clone();
if let Some(Payload::JobResult(r)) = &mut conflicting.payload {
r.state = "failed".into();
}
f.db.execute(
"UPDATE reconcile_results SET envelope=?1 WHERE id=?2",
params![conflicting.encode_to_vec(), prior.message_id],
)
.unwrap();
assert!(prepare(&mut fresh, &mut f).is_err());
f.db.execute(
"UPDATE reconcile_results SET envelope=?1 WHERE id=?2",
params![prior.encode_to_vec(), prior.message_id],
)
.unwrap();
let next = prepare(&mut fresh, &mut f).unwrap();
assert_eq!(
next.request.previous_decision_id,
signed.decision_id.to_string()
);
assert_eq!(
next.request.helper_previous_decision_id,
anchor.decision_id.to_string()
);
assert!(!fresh.can_start(&f.channel, true, &f.clock));
}
#[test]
fn independent_helper_checkpoint_regression_is_sticky() {
let mut f = Fixture::new();
+1 -1
View File
@@ -1,6 +1,6 @@
[package]
name = "rmm-agent-windows"
version = "0.1.15"
version = "0.1.16"
edition.workspace = true
license.workspace = true
+153 -10
View File
@@ -93,9 +93,26 @@ fn invalid() -> Error {
Error(StatusCode::CONFLICT, "MANAGED_SCRIPT_POLICY_INVALID")
}
// Only a managed device scope can opt in. The authenticated principal remains
// the token ID for authorization, the plan record and audit.
const SCOPED_MCP: &str = "mcp:scoped";
#[derive(Clone, Copy)]
enum HelperBinding {
LocalPins,
VerifiedInstalledRelease,
}
impl Policy {
fn permits(&self, principal: &str, job: &JobPayload, caps: &[String]) -> bool {
if !matches!(job.action, Action::RunScript { .. })
fn permits(
&self,
principal: &str,
job: &JobPayload,
caps: &[String],
binding: HelperBinding,
) -> bool {
if principal == SCOPED_MCP
|| !matches!(job.action, Action::RunScript { .. })
|| !job.action.full_maintenance()
|| !job.action.validate()
|| !job.action.available_for(&job.execution_identity, caps)
@@ -105,17 +122,23 @@ impl Policy {
{
return false;
}
match job.execution_identity.as_str() {
let permits_subject = |subject: &str| match job.execution_identity.as_str() {
"root" => self
.linux
.iter()
.any(|scope| scope.permits(principal, job, caps, None)),
.any(|scope| scope.permits(subject, job, caps, None)),
"system" => self
.windows
.iter()
.any(|scope| scope.permits(principal, job, caps, false, true, false)),
.any(|scope| scope.permits(subject, job, caps, false, true, false)),
_ => false,
}
};
permits_subject(principal)
|| (matches!(binding, HelperBinding::VerifiedInstalledRelease)
&& principal.strip_prefix("mcp:").is_some_and(|id| {
Uuid::parse_str(id).is_ok_and(|uuid| !uuid.is_nil() && uuid.to_string() == id)
})
&& permits_subject(SCOPED_MCP))
}
}
@@ -190,12 +213,11 @@ pub(crate) async fn permits(
{
return Err(invalid());
}
let direct = policy.permits(principal, job, caps);
if !caps
.iter()
.any(|cap| cap.starts_with("script.helper.release:"))
{
return Ok(direct);
return Ok(policy.permits(principal, job, caps, HelperBinding::LocalPins));
}
{
let release = Uuid::parse_str(single_value(caps, "script.helper.release:")?)
@@ -222,7 +244,12 @@ pub(crate) async fn permits(
}
})?;
check_pair(&manifest, version.as_deref(), &job.execution_identity, caps)?;
if direct {
if policy.permits(
principal,
job,
caps,
HelperBinding::VerifiedInstalledRelease,
) {
return Ok(true);
}
let current_policy = single_value(caps, "helper.policy.sha256:")?;
@@ -241,7 +268,12 @@ pub(crate) async fn permits(
});
pinned.push(format!("helper.binary.sha256:{}", anchor.helper_sha256));
pinned.push(format!("helper.policy.sha256:{original}"));
if policy.permits(principal, job, &pinned) {
if policy.permits(
principal,
job,
&pinned,
HelperBinding::VerifiedInstalledRelease,
) {
return Ok(true);
}
}
@@ -253,6 +285,117 @@ pub(crate) async fn permits(
mod tests {
use super::*;
use rmm_domain::agent_update::ArtifactDescriptor;
use serde_json::json;
#[test]
fn scoped_mcp_requires_a_device_opt_in_and_the_same_pinned_script_scope() {
let token = "mcp:12345678-abcd-4321-b123-123456789abc";
let verified = HelperBinding::VerifiedInstalledRelease;
let local = HelperBinding::LocalPins;
for (platform, identity, interpreter, script) in [
("linux", "root", "posix_sh", "true\n"),
("windows", "system", "powershell", "Write-Output 'ok'\r\n"),
] {
let mut job = JobPayload {
schema_version: 1,
tenant_id: Uuid::new_v4(),
asset_id: Uuid::new_v4(),
agent_id: Uuid::new_v4(),
enrollment_generation: 1,
assignment_version: 1,
job_id: Uuid::new_v4(),
attempt_id: Uuid::new_v4(),
action: Action::RunScript {
interpreter: interpreter.into(),
script_utf8: script.into(),
arguments: vec![],
expected_stdout: None,
windows_execution_profile: None,
privileged_script_profile: Some(
rmm_domain::jobs::PrivilegedScriptProfile::FullMaintenanceV1,
),
},
execution_identity: identity.into(),
not_before: chrono::Utc::now(),
start_before: chrono::Utc::now() + chrono::Duration::minutes(5),
max_runtime_seconds: 30,
max_output_bytes: 4096,
};
let binary = "ab".repeat(32);
let local_policy = "cd".repeat(32);
let mut caps = vec![
format!("{platform}.base/1"),
format!("helper.{identity}.v1"),
format!("{identity}:run_script"),
"run_script".into(),
"rmm.sync.v1".into(),
FULL_MAINTENANCE_CAPABILITY.into(),
format!("helper.policy.sha256:{local_policy}"),
format!("helper.binary.sha256:{binary}"),
];
let mut scope = json!({
"tenant_id": job.tenant_id, "asset_id": job.asset_id, "agent_id": job.agent_id,
"enrollment_generation": 1, "assignment_version": 1, "principals": ["local:reviewer"],
"helper_policy_sha256": local_policy, "helper_binary_sha256": binary,
"acceptance_evidence_id": Uuid::new_v4(), "allowed_services": [],
"allowed_script_profiles": ["full_maintenance_v1"]
});
if platform == "linux" {
scope["allow_root_scripts"] = json!(true);
scope["allow_reboot"] = json!(false);
} else {
scope["max_runtime_seconds"] = json!(30);
scope["allowed_script_sha256"] = json!([rmm_domain::jobs::hash(script.as_bytes())]);
caps.push("script.powershell/1".into());
}
let mut config = json!({"schema_version": 1, "linux": [], "windows": []});
config[platform] = json!([scope]);
let policy: Policy = serde_json::from_value(config.clone()).unwrap();
assert!(policy.permits("local:reviewer", &job, &caps, verified));
assert!(!policy.permits(token, &job, &caps, verified));
config[platform][0]["principals"] = json!(["local:reviewer", SCOPED_MCP]);
let policy: Policy = serde_json::from_value(config).unwrap();
assert!(policy.permits(token, &job, &caps, verified), "{platform}");
assert!(!policy.permits(token, &job, &caps, local));
assert!(policy.permits("local:reviewer", &job, &caps, local));
assert!(policy.permits("local:reviewer", &job, &caps, verified));
for other in [
SCOPED_MCP,
"local:other",
"mcp:not-a-uuid",
"mcp:00000000-0000-0000-0000-000000000000",
"mcp:12345678ABCD4321B123123456789ABC",
] {
assert!(
!policy.permits(other, &job, &caps, verified),
"{platform}: {other}"
);
}
let mut without_binary = caps.clone();
without_binary.retain(|cap| !cap.starts_with("helper.binary.sha256:"));
assert!(!policy.permits(token, &job, &without_binary, verified));
job.assignment_version += 1;
assert!(!policy.permits(token, &job, &caps, verified));
if platform == "windows" {
job.assignment_version -= 1;
if let Action::RunScript { arguments, .. } = &mut job.action {
arguments.push("other".into());
}
assert!(!policy.permits(token, &job, &caps, verified));
if let Action::RunScript {
script_utf8,
arguments,
..
} = &mut job.action
{
arguments.clear();
*script_utf8 = "Write-Output 'changed'\r\n".into();
}
assert!(!policy.permits(token, &job, &caps, verified));
}
}
}
#[test]
fn signed_helper_is_bound_to_platform_reported_version_and_unambiguous_local_pins() {
@@ -0,0 +1,76 @@
{
"source_commit": "e5006b3",
"platform": "x86_64-pc-windows-gnu",
"tenant": "11111111-1111-4111-8111-111111111111",
"prior": {
"agent_checkpoint": 1087,
"last_helper_applied_agent_checkpoint": 1083,
"open_local_attempts": 0,
"archived_unknown_revision": 1,
"acknowledged_final_revision": 2
},
"regression": {
"reconcile_tests_passed": 30,
"previous_code_on_copied_history": "CLOSED_CONTROL_EXACT_PARTIAL_EDGE",
"corrected_code_verified_historical_attempts": 13
},
"device": {
"version": "0.1.16",
"last_contact_utc": "2026-11-18T13:30:08.830033+00:00",
"generation": 57,
"agent_ready": true,
"helper_ready": true
},
"checkpoints": [
{
"checkpoint": 1443,
"created_at": "2026-11-18T13:29:20.16298+00:00",
"helper_ready": true,
"connection_generation": 56
},
{
"checkpoint": 1446,
"created_at": "2026-11-18T13:30:00.508677+00:00",
"helper_ready": true,
"connection_generation": 56
},
{
"checkpoint": 1451,
"created_at": "2026-11-18T13:30:11.907476+00:00",
"helper_ready": true,
"connection_generation": 57
}
],
"native": {
"observed": "2026-11-18T13:30:22.278132200Z",
"agent": "239ffa87-642f-40cd-9cbf-d48557dc0193",
"boot": "8ed9daf6-bf7c-824d-86ce-aca10db3ec03",
"release": "11c9af04-8cd8-4269-949f-63817690301a",
"agent_ready": true,
"helper_ready": true,
"unconfirmed": false,
"same_decision": true,
"new_decision": "d65d02be-e0fa-4f87-83fa-91c2f74301e7",
"starts": 1,
"result_count": 1
},
"job": {
"operation_id": "1d150e2a-e121-4a19-be15-087cb3e486ac",
"job_id": "2892a222-726b-4106-8a3a-406359e2d764",
"attempt_id": "8b474d61-0ea0-4cea-8508-b0f90c6475f4",
"original_plan_id": "dc1dadcc-84a8-48db-8b64-6c35c4c0e24f",
"approved_at": "2026-11-18T12:51:40.26421+00:00",
"identity": "agent_service",
"state": "failed",
"exit_code": 1,
"windows_sid": "S-1-5-19",
"outbox_ack": "2026-11-18T13:29:11.945329+00:00",
"grants": 1,
"grant_issued_at": "2026-11-18T13:29:15.226305+00:00"
},
"script_error": {
"hresult": "0x80070005",
"call": "IUpdateSearcher.GetTotalHistoryCount",
"account": "LocalService"
}
}
+3 -1
View File
@@ -9,12 +9,14 @@
| Gerät | Dienstkonto | Administrator | Neustart über die Bibliothek | Folgeauftrag |
| --- | --- | --- | --- | --- |
| dev-znuny-db | rmm-discovery, UID 990 | root, UID 0 | Version 1, Kernel-Bootwechsel bestätigt | rmm-discovery, Exitcode 0 |
| discwindowstest | LocalService, S-1-5-19 | SYSTEM, S-1-5-18 | Version 2 auf 0.1.15, Kernel-Bootwechsel bestätigt | LocalService, Exitcode 0 |
| discwindowstest | LocalService, S-1-5-19 | SYSTEM, S-1-5-18 | Version 2 auf 0.1.15, Kernel-Bootwechsel bestätigt | LocalService, Exitcode 0. Am 18.11. behob Windows GNU 0.1.16 in Development A den blockierten Helper-Abgleich nach einer quittierten Ergebnismeldung. Agent und Helper blieben auch nach einem Verbindungswechsel bereit. Der bereits genehmigte Auftrag zum Updateverlauf lief einmal als LocalService und meldete bei der Windows-Update-Abfrage Zugriff verweigert, Exitcode 1. [Nachweis](evidence/windows-helper-result-recovery-20261118.json) |
Auf Windows lieferte der erste Vorversuch Exitcode 0 und keine Ausgabe. Revision 2 meldete auf `0.1.14` den nativen Fehler 203. Der eingeschränkten Prozessumgebung fehlte `COMPUTERNAME`. Der aktualisierte Client ergänzte den nativen Rechnernamen. Dieselbe genehmigte Skriptrevision lieferte danach die Ankündigung des Neustarts, anschließend bestätigten Gast und Gateway den neuen Boot.
**Manifest-Gültigkeit für installierte Administrator-Helper.** Im Quellstand behoben. Der Server prüft die Gültigkeit zum gespeicherten Katalogzeitpunkt und verwendet den aktuellen Schlüsselring. Der Regressionstest prüft ein abgelaufenes Manifest in beiden Pfaden sowie den Widerruf des Signierschlüssels. Die HTTPS-Aufnahme und der Release-Katalog wurden zusätzlich mit isoliertem PostgreSQL geprüft.
**MCP-Abnahme mit individuellen Tokenrechten.** Beim neuen Versuch auf `dev-znuny-db` lehnte der Server den Root-Dateitest bei der Planung mit `SCRIPT_HELPER_SCOPE_DENIED` ab. Der Token hatte die Aktionsrechte, die zentrale Regel für den installierten Helper kannte den Antragsteller nicht. Die feste Bibliotheksrevision „Linux-Kernelversion“ wurde über MCP eingereicht. Die aktuelle Abnahme umfasst je Gerät die Datei mit `HelloWelt`, das Katalogergebnis, den Bootwechsel und einen Ping-Auftrag nach Wiederanmeldung. Zuerst Linux auswerten, dann die Windows-Test-VM prüfen. [Betriebsweg](public-access.md#administrator-skripte-anfordern)
## Ergänzte Lieferungen am 17. November 2026
- Umlautdarstellung für native PowerShell-Ausgabe korrigiert und am gespeicherten Updateergebnis in der WebUI geprüft. [Darstellung](evidence/powershell-output-encoding-20261117.json)
+5 -1
View File
@@ -1,6 +1,10 @@
# Verbindliche Projektentscheidungen
Stand: **2026-11-18**, Spezifikation **1.40** (`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.41** (`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.
## Zentrale Rechte für MCP-Skriptanträge (Version 1.41)
Die Rechte für Administrator-Skripte werden pro Token und Kunde auf dem Server vergeben. Ein vorbereiteter Client kann solche Aufträge ohne Benutzereingriff am Gerät abarbeiten. Für Betreiber gehört die Auswahl zulässiger Skripte zur Geräteregel und die Freigabe des konkreten Auftrags zu „Genehmigungen“. [Produktvertrag](../Rust_RMM_Implementierungsspezifikation.md#012-mcp-anträge-für-administrator-skripte-version-141)
## Release-Gültigkeit für installierte Skripthelfer (Version 1.40)
+15
View File
@@ -18,6 +18,21 @@ Die Kontokonfiguration liegt auf dem Server unter `/opt/rust-discovery/devstate/
## MCP-Tokens
### Administrator-Skripte anfordern
Für einen vollständigen Skriptauftrag braucht ein Token im Zielkunden `operations:plan`, `operations:submit`, `operations:read` und `scripts:execute`. Hinzu kommt für Administratoraufträge je Plattform `root:execute` oder `system:execute`. Zum Veröffentlichen einer Skriptversion benötigt das Token `operations:plan` und `scripts:execute`.
Auf einem Gerät mit installiertem, signiertem Administrator-Helper kann der Betreiber die vorhandene Geräteregel einmal für diese Tokenrechte öffnen. Der folgende Befehl zeigt den Zustand für genau die gewählte Regel. Die Werte in Großbuchstaben sind durch die Kennungen der Installation und der bestehenden Regel zu ersetzen.
```sh
python3 tools/dev_mcp_script_scope.py check --platform linux \
--tenant TENANT_ID --asset ASSET_ID --agent AGENT_ID --evidence ACCEPTANCE_EVIDENCE_ID
```
Mit `enable` wird der Eintrag `mcp:scoped` dieser Regel hinzugefügt, mit `disable` wieder entfernt. Für Windows lautet die Plattform `windows`. Der Server wertet die Regel bei der nächsten Rechteprüfung aus. Bereits separat an einzelne Tokens vergebene Rechte lassen sich durch Widerruf des Tokens entziehen. Ein freies Skript über `operations.plan` oder eine Bibliotheksversion über `scripts.plan` planen und über `operations.submit` einreichen. Die persönliche Entscheidung erfolgt in der WebUI. `jobs.get` liefert über die Auftragskennung den Stand und über die Jobkennung das Ausführungsergebnis.
### Token ausstellen
Nach der WebUI-Anmeldung unter **Verwaltung → MCP-Tokens** einen Namen, den Kundenkreis, die benötigten Rechte und ein Ablaufdatum wählen. Ein einzelner Kunde ist vorausgewählt. Weitere Kunden lassen sich einzeln ergänzen. „Alle aktuellen und zukünftigen Kunden“ ist eine eigene Option für Kundenadministratoren. Standard sind gespeichertes Inventar, Protokolle und Aufträge/Ergebnisse lesen. Der Tokenwert wird einmal angezeigt. Er kann anschließend im MCP-Client als HTTP-Header hinterlegt werden.
```http
+84
View File
@@ -0,0 +1,84 @@
#!/usr/bin/env python3
"""Manage scoped MCP planning on one existing Linux or Windows script-helper rule."""
import argparse
import fcntl
import inspect
import json
from pathlib import Path
import re
import stat
import subprocess
import uuid
from dev_linux_helper_rollover import POLICY, encoded, protected, replace, require
from dev_stage import ssh_prefix
def configure(path, platform, binding, action):
signer = (path.parent.parent / 'jobs/ed25519.pem').lstat()
require(stat.S_ISREG(signer.st_mode), 'Expected a regular job signer file')
owner = signer.st_uid
lock = path.with_name('operator.lock')
protected(path, owner)
lock_info = lock.lstat()
require(stat.S_ISREG(lock_info.st_mode) and lock_info.st_uid in (0, owner)
and not lock_info.st_mode & 0o022,
'Invalid operator.lock')
with lock.open('rb') as guard:
fcntl.flock(guard, fcntl.LOCK_EX)
info = protected(path, owner)
require(stat.S_IMODE(info.st_mode) == 0o600 and info.st_size <= 65536,
'Invalid managed policy file')
policy = json.loads(path.read_bytes())
require(policy['schema_version'] == 1, 'Unknown policy format')
matches = [scope for scope in policy[platform]
if all(scope.get(key) == value for key, value in binding.items())]
require(len(matches) == 1, 'Expected exactly one matching existing device rule')
scope = matches[0]
require(scope.get('allowed_script_profiles') == ['full_maintenance_v1']
and (platform != 'linux' or scope.get('allow_root_scripts') is True)
and all(re.fullmatch(r'[0-9a-f]{64}', scope.get(key) or '')
for key in ('helper_binary_sha256', 'helper_policy_sha256')),
'Rule does not describe a pinned administrator script helper')
principals = scope['principals']
require(isinstance(principals, list) and 1 <= len(principals) <= 64
and len(principals) == len(set(principals)),
'Invalid rule principals')
marker = 'mcp:scoped'
enabled = marker in principals
changed = action != 'check' and enabled != (action == 'enable')
if changed:
if action == 'enable':
require(len(principals) < 64, 'Rule principal list is full')
principals.append(marker)
else:
require(len(principals) > 1, 'Removing the last principal would invalidate this rule')
principals.remove(marker)
data = encoded(policy)
require(len(data) <= 65536, 'Managed policy exceeds the server size limit')
replace(path, data)
return {**binding, 'platform': platform, 'scoped_mcp_planning': marker in principals,
'changed': changed}
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('action', choices=('check', 'enable', 'disable'))
parser.add_argument('--platform', required=True, choices=('linux', 'windows'))
for field in ('tenant', 'asset', 'agent'):
parser.add_argument('--' + field, required=True, type=uuid.UUID)
parser.add_argument('--evidence', required=True, help='acceptance_evidence_id of the existing device rule')
args = parser.parse_args()
binding = dict(tenant_id=str(args.tenant), asset_id=str(args.asset), agent_id=str(args.agent),
acceptance_evidence_id=args.evidence)
# Send the same locked atomic file operations as helper rollover through the pinned SSH profile.
program = 'import fcntl,json,os,re,stat,tempfile\nfrom pathlib import Path\n'
for helper in (require, protected, encoded, replace, configure):
program += inspect.getsource(helper) + '\n'
params = (args.platform, binding, args.action)
program += f'print(json.dumps(configure(Path({str(POLICY)!r}), *{params!r})))\n'
subprocess.run([*ssh_prefix('server'), 'python3 -I -'], input=program, text=True, check=True)
if __name__ == '__main__':
main()