diff --git a/AGENTS.md b/AGENTS.md index 2050126..5c54569 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -1,15 +1,19 @@ # Verbindliche Regeln für alle Coding-KIs -**Entwicklungspause auf Userwunsch seit 2026-11-12:** Vor Wiederaufnahme -[docs/handover.md](docs/handover.md) lesen. Bis zu neuem Auftrag keine Entwicklung, -Builds, Tests, Deployments oder Jobs starten. +**Wiederaufnahme auf Userwunsch 2026-11-13.** Historische Übergabe: +[docs/handover.md](docs/handover.md). Neuer verbindlicher Topologieoverride: +[docs/server-deployment.md](docs/server-deployment.md). Der Entwickler-PC ist +kein RMM-Server mehr; der dedizierte Internetserver übernimmt diese Rolle. +**Korrektur 2026-11-13:** Dieses Notebook ist ausschließlich Entwicklungsrechner. +Hier keinen RMM-Client installieren, enrollen oder als Dienst starten. Aktueller +Client ist die Cloud-Test-VM; der festgelegte Cloudserver bleibt endgültiger Server. Diese Regeln gelten für alle AIs im gesamten Repository. Vor technischen Entscheidungen die **vollständige** `Rust_RMM_Implementierungsspezifikation.md`, `docs/project-decisions.md` und `docs/development.md` lesen. Normative Produktentscheidungen aus Kapitel 0 der Spezifikation haben Vorrang; Widersprüche offen dokumentieren, nicht stillschweigend abschwächen. ## Reihenfolge und reale Nachweise - **Linux-first für ALLE Features:** Zuerst auf der tatsächlichen Linux-Test-VM implementieren, ausführen und nachweisen. Lokale Tests, Simulatoren und Cross-Builds ergänzen den VM-Nachweis, ersetzen ihn nicht. -- Erstes Phasenziel ist das **Linux-MVP (M0–M5, x86-64)** mit WebUI, MCP und menschlich autorisierten dauerhaften Jobs. Windows beginnt erst nach dessen Abnahme. Proxmox/PBS, Cluster und Backups folgen noch später; kein Hypervisorzugang ist Voraussetzung eines Gastagenten. +- Erstes Phasenziel ist das **Linux-MVP (M0–M5, x86-64)** mit WebUI, MCP und menschlich autorisierten dauerhaften Jobs. **Useroverride 2026-11-13:** Windows-11-Client darf bereits parallel entwickelt und nativ auf der neuen Windows-Test-VM geprüft werden. Dies ersetzt keine Linux-Abnahme und macht Windows nicht zum Linux-MVP-Blocker. Notebook-Host bleibt ausschließlich Entwicklungsrechner; die Windows-VM ist ein eigener Gast. Proxmox/PBS, Cluster und Backups folgen noch später; kein Hypervisorzugang ist Voraussetzung eines Gastagenten. - **Useroverride 2026-11-12: RustDesk aus dieser Umsetzung auslassen.** Keine RustDesk-Installation, Profile/Provisionierung oder externe Desktopabnahme; RustDesk ist keine MVP-Pflicht und kein Abnahmeblocker. Bestehende Architekturverträge bleiben ausschließlich für eine spätere optionale Integration erhalten, ohne Ersatz durch eine eigene Desktop-Engine. - Kein Erfolg ohne realen Nachweis: geplant, implementiert, gebaut, lokal getestet, auf VM getestet und abgenommen getrennt ausweisen. Fehlende Zugänge/Tools/Capabilities und nicht ausgeführte Tests offen nennen. Keine erfundenen Messwerte oder Testergebnisse. @@ -23,11 +27,12 @@ Diese Regeln gelten für alle AIs im gesamten Repository. Vor technischen Entsch ## Entwicklungsweg und Sicherheit -- Server lokal in Docker auf dem Entwickler-PC; veröffentlichte Dockerports ausschließlich an Loopback binden, auch Datenbank/Verwaltungsports niemals an `0.0.0.0` oder `[::]`. -- PC baut SSH zur VM auf: Reverse-Forward **`-R 127.0.0.1:18443:127.0.0.1:18443`**, `-N -T`, `ExitOnForwardFailure` und Keepalive gemäß `docs/development.md`. VM-Agent verbindet sich ausgehend über dortigen Loopback. -- TLS Ende-zu-Ende zwischen VM-Agent und lokalem Server, DNS SAN **`rmm-dev.internal`**, expliziter VM-Hosts-Eintrag oder geprüfter Client-Connect-Override. Vertrauenswürdige Dev-CA installieren/konfigurieren; niemals ungültige Zertifikate/Namen akzeptieren, kein `curl -k` oder Abschalten der Verifikation. +- **Useroverride 2026-11-13:** Server auf dem dedizierten Internetserver, sämtliche Clients verbinden sich direkt ausgehend dorthin. Keine lokale Serverpflicht und kein PC→VM-Reversetunnel mehr. Details und tatsächlicher Deploymentstand in `docs/server-deployment.md`. +- Dockerports auch auf dem Internetserver ausschließlich an Loopback binden; PostgreSQL ohne veröffentlichten Port. Öffentlichen TLS-Ingress separat und eng begrenzt konfigurieren. Keine öffentlich erreichbare Dev-Anmeldung oder Datenbank; Verwaltungszugang bis zur sicheren öffentlichen Anmeldung ausschließlich über SSH-Tunnel. +- TLS Ende-zu-Ende zum Server, gültige Kette und zum Endpunkt passender SAN/SNI. Ein geprüfter Connect-Override verändert ausschließlich TCP-Ziel/Port. Vertrauenswürdige CA gezielt konfigurieren; niemals ungültige Zertifikate/Namen akzeptieren, kein `curl -k` oder Abschalten der Verifikation. - SSH ausschließlich Dev-/Bootstraptransport, kein RMM-Sicherheitsersatz: Enrollment, Geräteidentität/mTLS, Tenant-Grenzen, Planbindung und menschliche Genehmigung bleiben erforderlich. - VM-Zugangsdaten ausschließlich lokal in `credentials/linux-vm.conf`; `credentials/` über `.gitignore` ausschließen, Verzeichnismodus **700**, Dateimodus **600**. Keine Secrets aus Neugier lesen, loggen, committen oder in Jobausgaben/MCP-/LLM-Kontexte kopieren. Daten strikt parsen; **kein `source`, `eval` oder Ausführen von Konfigurationsinhalten**. +- Server-SSH-Daten entsprechend in `credentials/server.conf`; Root ist ausschließlich Bootstrapzugang. Anwendungsdienst unprivilegiert betreiben. Neue SSH-Hostschlüssel vor Anmeldung unabhängig bestätigen. - Entwicklungs-/Testtools dürfen installiert werden. Daraus folgen **keine impliziten Reboots, Updates oder destruktiven Tests am Ziel**, auch nicht an der Linux-Test-VM. Bootstrap eng begrenzen und abstimmen; RMM-Testjobs bleiben WebUI-genehmigungspflichtig. Sicherheitsprüfungen nicht für eine Demo umgehen. - Lokale Serverneustarts sind für diese Entwicklungsabnahme ausdrücklich erlaubt; daraus folgen keine impliziten VM-Reboots, Updates oder destruktiven Zieltests und keine Ersetzung der WebUI-Plangenehmigung. diff --git a/README.md b/README.md index 073acce..8532a05 100644 --- a/README.md +++ b/README.md @@ -1,8 +1,11 @@ # Rust Discovery / RMM — Linux-Entwicklungsslice -> **Entwicklung auf Userwunsch pausiert (2026-11-12).** Aktuelle Übergabe, -> bekannte Fehler und sicherer Laufzeitzustand: [docs/handover.md](docs/handover.md). -> Die älteren Slice-Beschreibungen unten sind historisch, keine aktuelle Gesamtübersicht. +> **Entwicklung wiederaufgenommen (2026-11-13).** Der Server zieht auf ausdrücklichen +> Userwunsch auf einen dedizierten Internetserver um; der Entwickler-PC dient +> ausschließlich als Entwicklungsrechner, ohne installierten RMM-Client. Die +> Cloud-Test-VM ist der aktuelle Client. Aktuelle Topologie und tatsächlicher +> Deploymentstand: [docs/server-deployment.md](docs/server-deployment.md). +> Die lokalen Serverbefehle und Slice-Beschreibungen unten sind historisch. **Kein fertiges MVP, keine Produktionsfreigabe.** Implementiert sind ein Rust-Workspace, PostgreSQL mit mandantenlokalen Transaktionen/RLS und eine passive Linux-Agentstrecke: diff --git a/Rust_RMM_Implementierungsspezifikation.md b/Rust_RMM_Implementierungsspezifikation.md index 97ca4f1..c1a49e8 100644 --- a/Rust_RMM_Implementierungsspezifikation.md +++ b/Rust_RMM_Implementierungsspezifikation.md @@ -1,6 +1,6 @@ # Rust RMM: Architektur und Implementierungsspezifikation -Version 1.5 · 2026-11-12 · Sprache: Deutsch +Version 1.8 · 2026-11-13 · 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. @@ -43,8 +43,40 @@ Version 1.5 · 2026-11-12 · Sprache: Deutsch ## 0 Auftrag und verbindliche Produktanforderungen +**Topologieoverride des Users vom 2026-11-13 (Version 1.6):** Der Entwickler-PC +wird nicht mehr als RMM-Server genutzt. Der dedizierte Internetserver übernimmt +Backend, Datenbank und TLS-Endpunkt; Agenten verbinden sich direkt ausgehend +mit diesem Server. **Präzisierung Version 1.7, ausdrückliche Userkorrektur vom +2026-11-13:** Dieses Notebook dient ausschließlich der Entwicklung und darf +nicht als RMM-Client installiert, enrolled oder betrieben werden. Der aktuelle +Testaufbau besteht aus der Cloud-Test-VM als Client und dem bereits endgültig +festgelegten Cloudserver `discovery.ease-technologies.de` als Server. Der kurzzeitig +installierte Notebook-Client wurde gestoppt/deinstalliert und seine Identität +über die WebUI widerrufen. Frühere Aussagen zum lokalen Notebook-Client sind +damit überstimmt. Frühere Vorgaben +„Server lokal in Docker auf dem PC“, PC→VM-Reversetunnel und VM-Loopback als +Serverziel sind hiermit historisch und überstimmt. Docker-Veröffentlichungen +bleiben Loopback, PostgreSQL bleibt intern; öffentlicher TLS-Ingress wird separat +abgesichert. Keine öffentliche Dev-Anmeldung. Bis zu einer eingerichteten sicheren +öffentlichen Anmeldung bleibt die WebUI nur über SSH-Tunnel erreichbar. +Root-SSH ist Bootstraptransport, der RMM-Dienst läuft unprivilegiert. TLS/mTLS, +Mandantentrennung und WebUI-Plangenehmigung bleiben verbindlich. +Deploymentdaten, offene Konfiguration und reale Nachweise: +`docs/server-deployment.md`. Diese Entscheidung ist kein Deploymentnachweis. + ### 0.1 Auftrag an die implementierende KI +**Useroverride Version 1.8, 2026-11-13:** Der User erlaubt ausdrücklich, +den Windows-11-Client bereits parallel zur offenen Linux-MVP-Abnahme zu +entwickeln und auf seiner Windows-Test-VM nativ zu prüfen. Die bisherige +Reihenfolgeregel „Windows erst nach Linux-MVP-Abnahme“ ist ausschließlich +hierfür überstimmt. Linux bleibt Referenz und erstes MVP-Abnahmeziel; +Windows-Nachweise bleiben separat und sind kein zusätzlicher Linux-MVP-Blocker. +Der Notebook-Host erhält keinen Agenten; die Windows-VM ist ein eigenständiger +Gast mit ausgehender Verbindung zum endgültigen Cloudserver. Bootstrapzugang +über abgesicherten Reverse-SSH-Tunnel ist erlaubt; TLS/mTLS, Mandantengrenzen +und die WebUI-Genehmigung jedes RMM-Jobs bleiben unverändert verbindlich. + Implementiere das in dieser Datei beschriebene System schrittweise. Beginne mit dem ersten vertikalen Abschnitt in Kapitel 25 und liefere lauffähige, überprüfbare Ergebnisse. Erzeuge nicht lediglich ein breites Gerüst mit leeren Methoden. Nutze die Startentscheidungen aus Kapitel 18, wenn konkrete Betriebsdaten noch fehlen. Halte tatsächlichen Implementierungsstand, offene Punkte und durchgeführte Prüfungen im Repository fest. Die Begriffe **MUSS**, **DARF NICHT** und **Abnahme** bezeichnen verbindliche Anforderungen. **Default** bezeichnet einen konfigurierbaren Startwert. **Optional** gehört nicht zum ersten Produktumfang. Die ausdrücklichen Entscheidungen der Version 1.5 in diesem Abschnitt haben bei Widersprüchen Vorrang vor früheren Architekturannahmen und Beispielen; sonst konkretisieren Kapitel 18 bis 26 die Architektur. Verbleibende Widersprüche werden dokumentiert und fachlich geklärt. diff --git a/crates/agent/src/bootstrap.rs b/crates/agent/src/bootstrap.rs index 204c517..27e4988 100644 --- a/crates/agent/src/bootstrap.rs +++ b/crates/agent/src/bootstrap.rs @@ -15,7 +15,7 @@ fn client(dir: &Path, address: SocketAddr, ca: &[u8]) -> Result .tls_built_in_root_certs(false) .add_root_certificate(reqwest::Certificate::from_pem(ca)?) .identity(reqwest::Identity::from_pem(&identity)?) - .resolve("rmm-dev.internal", address) + .resolve(&crate::https_channel::server_name()?, address) .no_proxy() .redirect(reqwest::redirect::Policy::none()) .connect_timeout(Duration::from_secs(10)) @@ -54,7 +54,8 @@ async fn download( ) -> Result<()> { let mut response = client .get(format!( - "https://rmm-dev.internal:{}/api/v1/job-signing-key", + "https://{}:{}/api/v1/job-signing-key", + crate::https_channel::server_name()?, address.port() )) .timeout(Duration::from_secs(15)) diff --git a/crates/agent/src/certificate_rotation.rs b/crates/agent/src/certificate_rotation.rs index 2b592dc..bf3b7ca 100644 --- a/crates/agent/src/certificate_rotation.rs +++ b/crates/agent/src/certificate_rotation.rs @@ -307,7 +307,8 @@ impl RotationStore { )?; let response = client .post(format!( - "https://rmm-dev.internal:{}/agent/v1/certificates/renew", + "https://{}:{}/agent/v1/certificates/renew", + crate::https_channel::server_name()?, address.port() )) .json(&serde_json::json!({"csr_pem": String::from_utf8(csr)?})) diff --git a/crates/agent/src/https_channel.rs b/crates/agent/src/https_channel.rs index b7f69c9..cd8e74f 100644 --- a/crates/agent/src/https_channel.rs +++ b/crates/agent/src/https_channel.rs @@ -15,7 +15,39 @@ pub const MAX_BODY: usize = 1024 * 1024; pub const MAX_BATCH: usize = 16; const MAX_INCOMING: usize = 32; -/// No environment proxy trust, redirects, alternate names or system CA fallback. +/// One configured DNS identity for URLs, SNI and certificate verification. +/// RMM_CONNECT_ADDR changes only the TCP destination, never this identity. +pub fn server_name() -> Result { + let name = match std::env::var("RMM_SERVER_NAME") { + Ok(name) => name, + Err(std::env::VarError::NotPresent) => "rmm-dev.internal".into(), + Err(error) => return Err(error.into()), + }; + validate_server_name(&name)?; + Ok(name) +} + +fn validate_server_name(name: &str) -> Result<()> { + ensure!( + !name.is_empty() + && name.len() <= 253 + && name.is_ascii() + && name.parse::().is_err() + && name.split('.').all(|label| { + !label.is_empty() + && label.len() <= 63 + && label.as_bytes()[0].is_ascii_alphanumeric() + && label.as_bytes()[label.len() - 1].is_ascii_alphanumeric() + && label + .bytes() + .all(|b| b.is_ascii_alphanumeric() || b == b'-') + }), + "INVALID_SERVER_NAME" + ); + Ok(()) +} + +/// No environment proxy trust, redirects or system CA fallback. /// `address` is a parsed RMM_CONNECT_ADDR; it overrides TCP only, never SNI. pub fn mtls_client(address: SocketAddr, ca: &[u8], cert: &[u8], key: &[u8]) -> Result { ensure!( @@ -31,7 +63,7 @@ pub fn mtls_client(address: SocketAddr, ca: &[u8], cert: &[u8], key: &[u8]) -> R .tls_built_in_root_certs(false) .add_root_certificate(reqwest::Certificate::from_pem(ca)?) .identity(reqwest::Identity::from_pem(&identity)?) - .resolve("rmm-dev.internal", address) + .resolve(&server_name()?, address) .no_proxy() .redirect(reqwest::redirect::Policy::none()) .connect_timeout(Duration::from_secs(10)) @@ -124,7 +156,7 @@ impl HttpsChannel { ); let mut channel = Self { client, - origin: format!("https://rmm-dev.internal:{}", address.port()), + origin: format!("https://{}:{}", server_name()?, address.port()), agent: hello.agent_id.clone(), enrollment: hello.enrollment_generation, generation: 0, @@ -324,3 +356,37 @@ impl HttpsChannel { Ok(()) } } + +#[cfg(test)] +mod endpoint_tests { + use super::*; + + #[test] + fn configured_dns_identity_cannot_inject_a_url_or_disable_name_checks() { + for name in ["rmm-dev.internal", "discovery.ease-technologies.de"] { + assert!(validate_server_name(name).is_ok()); + } + for name in [ + "", + "127.0.0.1", + "::1", + "host:443", + "https://host", + "user@host", + "host/path", + "host?query", + "host#fragment", + ".host", + "host.", + "a..b", + "-host.example", + "host-.example", + "white space", + "\nlocalhost", + "höst.example", + ] { + assert!(validate_server_name(name).is_err(), "{name:?}"); + } + assert!(validate_server_name(&format!("{}.example", "a".repeat(64))).is_err()); + } +} diff --git a/crates/agent/src/main.rs b/crates/agent/src/main.rs index 1fb4dd2..ca6f53d 100644 --- a/crates/agent/src/main.rs +++ b/crates/agent/src/main.rs @@ -648,14 +648,15 @@ async fn enrollment(dir: &Path, address: std::net::SocketAddr, ca: &[u8]) -> Res .https_only(true) .tls_built_in_root_certs(false) .add_root_certificate(reqwest::Certificate::from_pem(ca)?) - .resolve("rmm-dev.internal", address) + .resolve(&https_channel::server_name()?, address) .no_proxy() .redirect(reqwest::redirect::Policy::none()) .timeout(Duration::from_secs(15)) .build()?; let result = client .post(format!( - "https://rmm-dev.internal:{}/agent/v1/enroll", + "https://{}:{}/agent/v1/enroll", + https_channel::server_name()?, address.port() )) .json(&EnrollmentRequest { diff --git a/crates/agent/src/transport.rs b/crates/agent/src/transport.rs index 86b614c..cf1a763 100644 --- a/crates/agent/src/transport.rs +++ b/crates/agent/src/transport.rs @@ -40,7 +40,11 @@ pub async fn connect( let (channel, _) = timeout( Duration::from_secs(10), tokio_tungstenite::client_async_tls_with_config( - format!("wss://rmm-dev.internal:{}/agent/v1/connect", address.port()), + format!( + "wss://{}:{}/agent/v1/connect", + crate::https_channel::server_name()?, + address.port() + ), tcp, Some(ws), Some(Connector::Rustls(Arc::new(config))), diff --git a/crates/server/src/api.rs b/crates/server/src/api.rs index 126de6e..f62d583 100644 --- a/crates/server/src/api.rs +++ b/crates/server/src/api.rs @@ -31,6 +31,16 @@ pub async fn job_signing_key( json!({"key_id":state.job_signer.key_id,"algorithm":"Ed25519","schema_version":1,"public_key_hex":hex::encode(state.job_signer.public_key().map_err(|_|StatusCode::INTERNAL_SERVER_ERROR)?)}), )) } +pub async fn agent_job_signing_key( + State(state): State, + h: HeaderMap, + Extension(peer): Extension, +) -> Result, StatusCode> { + if h.contains_key("authorization") || h.contains_key("cookie") || peer.0.is_none() { + return Err(StatusCode::UNAUTHORIZED); + } + job_signing_key(State(state), h, Extension(peer)).await +} pub async fn device( State(state): State, headers: HeaderMap, diff --git a/crates/server/src/main.rs b/crates/server/src/main.rs index 162cd22..ad02b49 100644 --- a/crates/server/src/main.rs +++ b/crates/server/src/main.rs @@ -141,6 +141,10 @@ async fn main() -> Result<()> { get(agent_artifacts::download), ) .route("/agent/v1/connect", get(gateway::connect)); + if !role.api() { + // Public gateway never accepts browser or automation credentials. + routes = routes.route("/api/v1/job-signing-key", get(api::agent_job_signing_key)); + } } if role.api() { if dev { diff --git a/deploy/browser/cloud-root.config.ts b/deploy/browser/cloud-root.config.ts new file mode 100644 index 0000000..2599092 --- /dev/null +++ b/deploy/browser/cloud-root.config.ts @@ -0,0 +1,22 @@ +import { defineConfig } from '../../web/node_modules/@playwright/test/index.js'; +import { resolve } from 'node:path'; +import { readdirSync, existsSync } from 'node:fs'; + +const root = resolve(__dirname, '../..'); +const browsers = resolve(root, 'web/node_modules/.cache/playwright-browsers'); +const version = readdirSync(browsers).find(x => /^chromium-/.test(x)); +if (!version) throw new Error('Installed Chromium required'); +const executablePath = ['chrome-linux/chrome', 'chrome-linux64/chrome'] + .map(x => resolve(browsers, version, x)).find(x => existsSync(x)); +if (!executablePath) throw new Error('Installed Chromium required'); +export default defineConfig({ + testDir: '../../tests/browser', testMatch: 'mvp-actions.spec.ts', workers: 1, + fullyParallel: false, retries: 0, timeout: 120000, + reporter: [['../../tests/browser/safe-reporter.ts']], + outputDir: '../../web/node_modules/.cache/cloud-acceptance/results', + use: { browserName: 'chromium', baseURL: 'https://localhost:18443', + actionTimeout: 15000, navigationTimeout: 20000, + ignoreHTTPSErrors: false, timezoneId: 'UTC', trace: 'off', screenshot: 'off', video: 'off', + launchOptions: { executablePath, env: { ...process.env, + HOME: resolve(root, 'web/node_modules/.cache/cloud-acceptance/home') } } }, +}); diff --git a/deploy/browser/cloud_approve.cjs b/deploy/browser/cloud_approve.cjs new file mode 100644 index 0000000..1e8faab --- /dev/null +++ b/deploy/browser/cloud_approve.cjs @@ -0,0 +1,59 @@ +// Actual UI only. No page.request, fetch injection, approval API or DB access. +const fs = require('node:fs'); +const path = require('node:path'); +const crypto = require('node:crypto'); +const { chromium } = require('../../web/node_modules/playwright'); +const root = path.resolve(__dirname, '../..'); +const assert = (value) => { if (!value) throw new Error('UI contract mismatch'); }; +(async () => { + const file = path.resolve(process.argv[2]); + const stat = fs.lstatSync(file); + assert(stat.isFile() && !stat.isSymbolicLink() && stat.uid === process.getuid() && (stat.mode & 0o777) === 0o600); + const expected = JSON.parse(fs.readFileSync(file, 'utf8')); + assert(expected.profile === 'dev/test' && ['hello', 'refresh_inventory', 'cancel_queued'].includes(expected.case)); + assert(expected.expected_principal === 'simulated-testprincipal-a'); + const loginFile = path.join(root, 'credentials/server-browser-login.json'); + const loginStat = fs.lstatSync(loginFile); + assert(loginStat.isFile() && !loginStat.isSymbolicLink() && loginStat.uid === process.getuid() && (loginStat.mode & 0o777) === 0o600); + const login = JSON.parse(fs.readFileSync(loginFile, 'utf8')); + const cache = path.join(root, 'web/node_modules/.cache/cloud-acceptance'); + const browserRoot = path.join(root, 'web/node_modules/.cache/playwright-browsers'); + const version = fs.readdirSync(browserRoot).find(x => /^chromium-/.test(x)); + const candidates = ['chrome-linux/chrome', 'chrome-linux64/chrome'].map(x => path.join(browserRoot, version, x)); + const browser = await chromium.launch({ headless: true, executablePath: candidates.find(x => fs.existsSync(x)), + env: { ...process.env, HOME: path.join(cache, 'home') } }); + try { + const page = await browser.newPage({ ignoreHTTPSErrors: false }); + await page.goto('https://localhost:18443/'); + await page.getByLabel('Benutzername').fill(login.username); + await page.getByLabel('Passwort', { exact: true }).fill(login.password); + const sessionResponse = page.waitForResponse(r => new URL(r.url()).pathname === '/auth/session' && r.status() === 200); + await page.getByRole('button', { name: 'Anmelden', exact: true }).click(); + const session = await (await sessionResponse).json(); + assert(session.testsimulation === true && session.approval_origin === 'dev_test_browser_simulation' && session.principal === expected.expected_principal); + await page.getByRole('status').filter({ hasText: 'SIMULIERT' }).waitFor(); + await page.getByRole('button', { name: expected.operation_id, exact: true }).click(); + const op = page.locator('section').filter({ has: page.getByRole('heading', { name: 'Antrag / Ausführung ' + expected.operation_id, exact: true }) }); + const pending = JSON.parse(await op.locator('pre').first().innerText()); + assert(pending.approval_state === 'pending_approval' && pending.job_count === 0 && pending.execution_state === null); + await op.getByRole('button', { name: 'Unveränderlichen Plan zur Prüfung öffnen', exact: true }).click(); + const detail = page.locator('section').filter({ has: page.getByRole('heading', { name: 'Unveränderlicher Plan / Genehmigungsdetail', exact: true }) }); + const rendered = JSON.parse(await detail.locator('pre').first().innerText()); + assert(rendered.plan_hash === expected.plan.plan_hash && crypto.createHash('sha256').update(Buffer.from(rendered.plan_payload_bytes)).digest('hex') === expected.plan.plan_hash); + assert(JSON.stringify(rendered.plan_payload_bytes) === JSON.stringify(expected.plan.plan_payload_bytes)); + assert(rendered.jobs.length === 1 && rendered.resolved_targets.length === 1); + const job = rendered.jobs[0]; const payload = job.payload; + assert(job.job_payload_hash === expected.job.job_payload_hash && JSON.stringify(payload) === JSON.stringify(expected.job.payload)); + assert(payload.agent_id === expected.agent_id && payload.asset_id === expected.asset_id && payload.tenant_id === expected.tenant_id); + assert(payload.execution_identity === 'agent_service' && payload.max_runtime_seconds === 60 && payload.max_output_bytes <= 65536); + assert(Date.parse(payload.start_before) > Date.now()); + if (expected.case === 'hello' || expected.case === 'cancel_queued') assert(payload.action.action === 'run_script' && payload.action.interpreter === 'posix_sh' && payload.action.script_utf8 === "printf '%s\\n' 'Hello World'\n" && payload.action.expected_stdout === 'Hello World\n'); + else assert(payload.action.action === 'refresh_inventory' && payload.action.scope === 'linux.base'); + const approve = detail.getByRole('button', { name: 'SIMULIERT: Diesen festen Plan ausdrücklich genehmigen', exact: true }); + assert(await approve.isDisabled()); + await detail.getByRole('checkbox', { name: 'Ich habe sämtliche festen Ziele', exact: false }).check(); + await approve.click(); + await op.locator('p.warning').filter({ hasText: 'Antrag: approved' }).waitFor(); + await page.getByRole('button', { name: 'Abmelden', exact: true }).click(); + } finally { await browser.close(); } +})().catch(error => { console.log('CLOUD_UI_INCOMPLETE:' + error.constructor.name); process.exitCode = 1; }); diff --git a/deploy/browser/cloud_apt_diagnostic.cjs b/deploy/browser/cloud_apt_diagnostic.cjs new file mode 100644 index 0000000..2107c30 --- /dev/null +++ b/deploy/browser/cloud_apt_diagnostic.cjs @@ -0,0 +1,94 @@ +// Actual UI interactions only; credentials remain in the protected login file. +const fs = require('node:fs'); +const path = require('node:path'); +const crypto = require('node:crypto'); +const { isDeepStrictEqual } = require('node:util'); +const { chromium } = require('../../web/node_modules/playwright'); +const root = path.resolve(__dirname, '../..'); +const assert = value => { if (!value) throw new Error('Diagnostic UI contract mismatch'); }; +function readPrivate(file) { + const s = fs.lstatSync(file); + assert(s.isFile() && !s.isSymbolicLink() && s.uid === process.getuid() && (s.mode & 0o777) === 0o600 && s.size < 1048576); + return JSON.parse(fs.readFileSync(file, 'utf8')); +} +(async () => { + const file = path.resolve(process.argv[2]); const expected = readPrivate(file); + assert(expected.profile === 'dev/test' && expected.case === 'apt_diagnostic_v1' && expected.expected_principal === 'simulated-testprincipal-a'); + const source = fs.readFileSync(path.join(root, 'deploy/linux/apt-diagnostic.py'), 'utf8'); + const script = "exec /usr/bin/python3 -I - <<'RMM_APT_DIAGNOSTIC'\n" + source + '\nRMM_APT_DIAGNOSTIC\n'; + const login = readPrivate(path.join(root, 'credentials/server-browser-login.json')); + const browsers = path.join(root, 'web/node_modules/.cache/playwright-browsers'); + const version = fs.readdirSync(browsers).find(x => /^chromium-/.test(x)); + const executablePath = ['chrome-linux/chrome', 'chrome-linux64/chrome'].map(x => path.join(browsers, version, x)).find(x => fs.existsSync(x)); + const browser = await chromium.launch({ headless: true, executablePath, + env: { ...process.env, HOME: path.join(root, 'web/node_modules/.cache/cloud-acceptance/home') } }); + try { + const page = await browser.newPage({ ignoreHTTPSErrors: false, timezoneId: 'UTC' }); + page.setDefaultTimeout(15000); + let approvals = 0; + page.on('request', r => { if (new URL(r.url()).pathname.endsWith('/authorizations')) approvals++; }); + await page.goto('https://localhost:18443/'); + await page.getByLabel('Benutzername').fill(login.username); + await page.getByLabel('Passwort', { exact: true }).fill(login.password); + const response = page.waitForResponse(r => new URL(r.url()).pathname === '/auth/session' && r.status() === 200); + await page.getByRole('button', { name: 'Anmelden', exact: true }).click(); + const session = await (await response).json(); + assert(session.testsimulation === true && session.approval_origin === 'dev_test_browser_simulation' && session.principal === expected.expected_principal); + await page.getByRole('status').filter({ hasText: 'SIMULIERT' }).waitFor(); + if (expected.phase === 'prepare') { + assert(expected.request.parameters.variants[0].script_utf8 === script && expected.request.parameters.expected_stdout === null); + await page.getByRole('checkbox', { name: 'Ziel ' + expected.asset_id, exact: true }).check(); + await page.getByLabel('Aktion', { exact: true }).selectOption('run_script'); + await page.getByRole('combobox', { name: 'Interpreter', exact: true }).selectOption('posix_sh'); + await page.getByLabel('Exakte UTF-8 Skriptbytes', { exact: false }).fill(script); + await page.getByLabel('Erwartete stdout-Ausgabe', { exact: false }).fill(''); + await page.getByLabel('Ausführungsidentität', { exact: true }).selectOption('root'); + await page.getByLabel('Laufzeitlimit (s)', { exact: true }).fill('90'); + await page.getByLabel('Ausgabelimit (Bytes)', { exact: true }).fill('16384'); + const start = new Date(Math.ceil(Date.now() / 60000) * 60000); + await page.getByLabel('Frühester Start (lokale Zeit)', { exact: true }).fill(start.toISOString().slice(0, 16)); + await page.getByLabel('Startfrist / Ablauf (lokale Zeit)', { exact: true }).fill(new Date(start.getTime() + 15 * 60000).toISOString().slice(0, 16)); + await page.getByLabel('Maximal parallel', { exact: true }).fill('1'); + await page.getByLabel('Stopp nach Fehlern', { exact: true }).fill('1'); + await page.getByLabel('Begründung', { exact: true }).fill(expected.request.reason); + await page.getByRole('button', { name: 'Plan erstellen · noch keine Ausführung' }).click(); + const detail = page.locator('section').filter({ has: page.getByRole('heading', { name: 'Unveränderlicher Plan / Genehmigungsdetail', exact: true }) }); + const plan = JSON.parse(await detail.locator('pre').innerText()); + assert(crypto.createHash('sha256').update(Buffer.from(plan.plan_payload_bytes)).digest('hex') === plan.plan_hash); + await detail.getByRole('button', { name: 'Antrag absenden · pending_approval' }).click(); + const op = page.locator('section').filter({ has: page.getByRole('heading', { name: /^Antrag \/ Ausführung / }) }); + await op.locator('pre').first().filter({ hasText: '"job_count": 0' }).waitFor(); + const operation = JSON.parse(await op.locator('pre').first().innerText()); + assert(operation.approval_state === 'pending_approval' && operation.execution_state === null && approvals === 0); + assert(path.dirname(path.resolve(expected.output_file)) === path.dirname(file)); + fs.writeFileSync(expected.output_file, JSON.stringify({ plan, operation }), { flag: 'wx', mode: 0o600 }); + } else { + assert(expected.phase === 'approve'); + await page.getByRole('button', { name: expected.operation_id, exact: true }).click(); + const op = page.locator('section').filter({ has: page.getByRole('heading', { name: 'Antrag / Ausführung ' + expected.operation_id, exact: true }) }); + const pending = JSON.parse(await op.locator('pre').first().innerText()); + assert(pending.approval_state === 'pending_approval' && pending.job_count === 0 && pending.execution_state === null); + await op.getByRole('button', { name: 'Unveränderlichen Plan zur Prüfung öffnen' }).click(); + const detail = page.locator('section').filter({ has: page.getByRole('heading', { name: 'Unveränderlicher Plan / Genehmigungsdetail', exact: true }) }); + const plan = JSON.parse(await detail.locator('pre').innerText()); + assert(plan.plan_hash === expected.plan.plan_hash && crypto.createHash('sha256').update(Buffer.from(plan.plan_payload_bytes)).digest('hex') === plan.plan_hash); + assert(JSON.stringify(plan.plan_payload_bytes) === JSON.stringify(expected.plan.plan_payload_bytes)); + assert(plan.jobs.length === 1 && plan.resolved_targets.length === 1); + const job = plan.jobs[0]; const p = job.payload; + assert(isDeepStrictEqual(job, expected.plan.jobs[0])); + assert(p.agent_id === expected.agent_id && p.asset_id === expected.asset_id && p.tenant_id === expected.tenant_id); + assert(p.execution_identity === 'root' && p.max_runtime_seconds === 90 && p.max_output_bytes === 16384 && Date.parse(p.start_before) > Date.now()); + assert(isDeepStrictEqual(p.action, { action: 'run_script', interpreter: 'posix_sh', script_utf8: script, arguments: [], expected_stdout: null })); + const button = detail.getByRole('button', { name: 'SIMULIERT: Diesen festen Plan ausdrücklich genehmigen', exact: true }); + assert(await button.isDisabled()); + await detail.getByRole('checkbox', { name: 'Ich habe sämtliche festen Ziele', exact: false }).check(); + await button.click(); + await op.locator('p.warning').filter({ hasText: 'Antrag: approved' }).waitFor(); + } + await page.getByRole('button', { name: 'Abmelden', exact: true }).click(); + } finally { await browser.close(); } +})().catch(error => { + const line = error.stack?.match(/cloud_apt_diagnostic\.cjs:(\d+):\d+/)?.[1] || 'unknown'; + console.log('CLOUD_APT_DIAGNOSTIC_UI_INCOMPLETE:' + error.constructor.name + ':source_line=' + line); + process.exitCode = 1; +}); diff --git a/deploy/browser/run_cloud_root.py b/deploy/browser/run_cloud_root.py new file mode 100644 index 0000000..8be1d58 --- /dev/null +++ b/deploy/browser/run_cloud_root.py @@ -0,0 +1,41 @@ +#!/usr/bin/env python3 +"""Cloud-only existing UI contracts; never starts a server, agent or fixture.""" +import argparse +import os +import re +from pathlib import Path +import subprocess +import sys + +sys.path.insert(0,str(Path(__file__).resolve().parents[1])) +import cloud_mvp_acceptance as cloud + +CASES=('service_setup','service_start','service_stop','apt_native_install','apt_native_update','ensure_package','apply_updates') + + +def run(file,prepare=False): + value=cloud.contract.protected_json(file) + cloud.require(value.get('profile')=='dev/test' and value.get('case') in CASES and + value.get('expected_principal')=='simulated-testprincipal-a','fixed cloud root cases only') + if prepare: + cloud.require(value.get('phase')=='prepare' and value['request']['parameters']['execution_identity']=='root','root preparation only') + cloud.prepare_browser() + env={k:v for k,v in os.environ.items() if k not in ('DEBUG','PWDEBUG','NODE_DEBUG')} + env.update(RMM_E2E_PROFILE='dev/test',RMM_E2E_MODE='mvp-prepare' if prepare else 'mvp-actions', + RMM_E2E_CASE_FILE=str(Path(file).resolve()),RMM_E2E_LOGIN_FILE=str(cloud.ROOT/'credentials/server-browser-login.json'),TZ='UTC') + result=subprocess.run(['node',str(cloud.ROOT/'web/node_modules/@playwright/test/cli.js'),'test', + '--config',str(cloud.ROOT/'deploy/browser/cloud-root.config.ts')],cwd=cloud.ROOT,env=env, + capture_output=True,timeout=150) + # The dedicated reporter emits only generic statuses. Never publish raw + # browser failures, request headers, page state or entered credentials. + if result.returncode!=0: + lines=re.findall(rb'Cloud/root UI failure source_line=(\d+)',result.stdout) + raise cloud.contract.GuardError('cloud_root_UI_incomplete_no_automatic_repeat; source_lines='+','.join(x.decode('ascii') for x in lines)) + + +if __name__=='__main__': + parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('--case-file',required=True) + parser.add_argument('--prepare-only',action='store_true');args=parser.parse_args() + try:run(args.case_file,args.prepare_only) + except Exception: + print('CLOUD_ROOT_UI_INCOMPLETE; no automatic repeat');raise SystemExit(2) from None diff --git a/deploy/cloud_apt_followup.py b/deploy/cloud_apt_followup.py new file mode 100644 index 0000000..edbac59 --- /dev/null +++ b/deploy/cloud_apt_followup.py @@ -0,0 +1,132 @@ +#!/usr/bin/env python3 +"""Cloud APT diagnosis: no install/retry, actual pending + separate UI approval.""" +import argparse +import datetime as dt +import hashlib +import json +import os +from pathlib import Path +import subprocess +import time +import uuid +import cloud_mvp_acceptance as cloud +import cloud_root_policy + +ROOT=cloud.ROOT +require=cloud.require +STATE=ROOT/'devstate/cloud-apt-followup' + + +def narrow_policy(payload): + import datetime as dt + p=Path('/opt/rust-discovery/devstate/root-policy/policy.json') + require(not p.is_symlink() and p.stat().st_uid==10001 and p.stat().st_mode&0o777==0o600,'unsafe policy') + old=p.read_bytes();require(hashlib.sha256(old).hexdigest()==payload['expected_sha256'],'existing policy changed') + require(dt.datetime.fromisoformat(json.loads(old)['expires_at'])=contract.timestamp(request['schedule']['not_before']),'fresh_inventory_required') + gate=evidence('gate',job_id=job['job_id']);audit=evidence('audit',operation_id=pending['operation_id']) + expected_counts=[1,1,0] if args.case=='cancel_queued' else [1,1,1] + contract.require([gate[k] for k in ('jobs','outbox','permits')]==expected_counts,'exact_job_outbox_grant_counts') + contract.require(audit==dict(origin='dev_test_browser_simulation',simulation=True,principal=checkpoint['expected_principal'],plan_hash=plan['plan_hash']),'interactive_simulation_audit') + checkpoint.update(verified=True,postapproval=gate,audit=audit);save() + print('PASS cloud VM '+args.case+': MCP pending 0/0/0, actual simulated UI approval, verified counts '+str(expected_counts)) + + +if __name__=='__main__': + try:main() + except Exception as error: + print('CLOUD_ACCEPTANCE_INCOMPLETE:'+ (str(error) if isinstance(error,contract.GuardError) else type(error).__name__)) + raise SystemExit(2) from None diff --git a/deploy/cloud_root_acceptance.py b/deploy/cloud_root_acceptance.py new file mode 100644 index 0000000..5b1a0c4 --- /dev/null +++ b/deploy/cloud_root_acceptance.py @@ -0,0 +1,108 @@ +#!/usr/bin/env python3 +"""One cloud-only Root/APT UI acceptance, never a retry or direct approval. + +Preparation and approval are separate real browser sessions. MCP/SQL only read +the root request and prove zero execution artifacts before the UI approval. +Existing case directories are never reused; unknown effects stop progress. +""" +import argparse +import hashlib +import json +import os +from pathlib import Path +import sys +import time + +import cloud_mvp_acceptance as cloud +import cloud_root_evidence +import vm_mvp_adapters as adapters +sys.path.insert(0,str(Path(__file__).resolve().parent/'browser')) +import run_cloud_root as browser + + +def main(): + parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('--case',choices=browser.CASES,required=True) + parser.add_argument('--resume-prepared',action='store_true',help='Only an existing still-pending UI request with zero executable artifacts') + args=parser.parse_args() + os.umask(0o077);m=cloud.contract;name=args.case + m.require(not (Path.home()/'.local/share/rust-discovery/remote-agent').exists(),'notebook must remain development only') + installed=m.protected_json(cloud.ROOT/'devstate/remote-vm.json');identity=installed['identity'] + settings=dict(tenant_id=cloud.TENANT,**identity);backend=cloud.Backend() + def evidence(kind,**extra):return cloud.bootstrap.rpc('server.conf',cloud.server,dict(kind=kind,tenant_id=cloud.TENANT,agent_id=identity['agent_id'],**extra)) + m.require(evidence('gate')['unresolved']==0,'unresolved central job; no new attempt') + observed=cloud.bootstrap.rpc('server.conf',cloud.bootstrap.server,dict(action='observe',agent_id=identity['agent_id'])) + m.require(observed['sync_ready'] and not observed['restore_blocked'],'signed sync required') + device=backend.call('inventory.get_device',dict(tenant_id=cloud.TENANT,asset_id=identity['asset_id'])) + m.require(device['presence']=='online' and device['agent_id']==identity['agent_id'],'online cloud VM required') + peers=cloud.bootstrap.rpc('linux-vm.conf',cloud_root_evidence.inspect_helpers,{k:settings[k] for k in ('tenant_id','asset_id','agent_id')}) + m.require(peers['ledger']['integrity']=='ok' and peers['ledger']['faults']==0,'healthy shared helper ledger required') + if name in adapters.APT_CASES: + apt_peer=peers['apt'];recipe=adapters.RECIPES[name] + m.require(apt_peer['fixture_acceptance_ready'] and recipe in apt_peer['bootstrap_recipes'] if name.startswith('apt_native_') + else recipe in apt_peer['accepted_recipes'],'actual native bootstrap/acceptance gate required') + planning=adapters.planning_from_device(device) if name in adapters.APT_CASES else None + request=m.case_input(name,settings,planning=planning) + m.require({'rmm.sync.v1','helper.root.v1','root:'+request['action'],request['action']}<=set(device['capabilities']),'native root capability required') + folder=cloud.ROOT/'devstate/cloud-root/cases'/name + if not args.resume_prepared:folder.mkdir(mode=0o700,parents=True,exist_ok=False) + prepared=folder/'prepared.json';preparation=folder/'prepare.json' + if args.resume_prepared: + previous=m.protected_json(preparation) + m.require(previous['case']==name and all(previous[k]==settings[k] for k in settings),'existing preparation target mismatch') + request=previous['request'] + else: + m.write_private(preparation,dict(profile='dev/test',case=name,phase='prepare',request=request,**settings, + expected_principal='simulated-testprincipal-a',output_file=str(prepared))) + print(name+': prepare through actual UI',flush=True);browser.run(preparation,prepare=True) + response=m.protected_json(prepared);plan=response['plan'];pending=response['operation'] + m.require(hashlib.sha256(bytes(plan['plan_payload_bytes'])).hexdigest()==plan['plan_hash'] and len(plan['jobs'])==1,'immutable plan bytes') + job=plan['jobs'][0];payload=job['payload'] + m.require(payload['execution_identity']=='root' and all(payload[k]==settings[k] for k in ('tenant_id','asset_id','agent_id')),'fixed cloud root target') + stored=backend.call('jobs.get',dict(tenant_id=cloud.TENANT,operation_id=pending['operation_id'])) + gate=evidence('gate',job_id=job['job_id']) + m.require(stored['plan_hash']==plan['plan_hash'] and stored['approval_state']=='pending_approval' and stored['job_count']==0 + and stored['execution_state'] is None and all(gate[k]==0 for k in ('jobs','outbox','permits')),'pending must have zero executable artifacts') + checkpoint=dict(case=name,plan=plan,job=job,request=request,operation_id=pending['operation_id'],preapproval=gate,helper_readiness=peers,stage='pending_approval') + path=folder/'checkpoint.json' + def save(): + # Checkpoint belongs to this exclusive invocation; retain result records + # separately and never submit/approve again after an interruption. + path.write_text(json.dumps(checkpoint,indent=2));path.chmod(0o600) + save() + approval=folder/'approve.json' + m.write_private(approval,dict(profile='dev/test',case=name,**settings,expected_principal='simulated-testprincipal-a', + operation_id=pending['operation_id'],plan_hash=plan['plan_hash'],plan_payload_bytes=plan['plan_payload_bytes'], + job_payload=payload,job_payload_hash=job['job_payload_hash'])) + print(name+': pending verified 0/0/0; separate actual UI approval',flush=True);browser.run(approval) + end=time.monotonic()+420 + while True: + result=backend.call('jobs.get',dict(tenant_id=cloud.TENANT,job_id=job['job_id'])) + if result['state'] in m.TERMINAL or result['state'] in ('unknown','awaiting_reboot'):break + m.require(time.monotonic()', line) + line = re.sub(r'/[^\s\x27\x22,;()]+', '', line) + line = re.sub(r'\b(?:\d{1,3}\.){3}\d{1,3}\b', '
', line) + messages.append(line[:512]) + results.append(dict(case=name,exit_code=process.returncode,messages=messages[:12], + stdout_sha256=digest(stdout),stderr_sha256=digest(stderr),truncated=any(n>16384 for n in lengths), + solver_selected_fixture=b'rmm-mvp-test' in stdout)) + assert preserved() == before and not Path('/usr/share/rmm-mvp-test/version').exists() + print(json.dumps(dict(schema_version=1,diagnostic_only=True,transaction_executed=False, + preserved_state=True,original_config_sha256=digest(config),results=results))) + + +if __name__ == '__main__': + main() diff --git a/deploy/linux/rmm-agent-remote.service b/deploy/linux/rmm-agent-remote.service new file mode 100644 index 0000000..2980520 --- /dev/null +++ b/deploy/linux/rmm-agent-remote.service @@ -0,0 +1,36 @@ +[Unit] +Description=RMM unprivileged client for discovery.ease-technologies.de +After=network-online.target time-sync.target +Wants=network-online.target + +[Service] +Type=simple +User=rmm-agent +Group=rmm-agent +StateDirectory=rmm-agent-remote +StateDirectoryMode=0700 +UMask=0077 +Environment=RMM_AGENT_STATE=/var/lib/rmm-agent-remote +Environment=RMM_CA_FILE=/etc/rmm-remote/ca.pem +Environment=RMM_SERVER_NAME=discovery.ease-technologies.de +Environment=RMM_CONNECT_ADDR=88.99.80.202:443 +Environment=RMM_TRANSPORT=auto +Environment=RMM_EXTENDED_INVENTORY=1 +EnvironmentFile=/etc/rmm-remote/agent.env +ExecStart=/usr/local/libexec/rmm-agent-remote +Restart=on-failure +RestartSec=10 +NoNewPrivileges=true +PrivateTmp=true +ProtectSystem=strict +ProtectHome=true +ProtectKernelTunables=true +ProtectKernelModules=true +ProtectControlGroups=true +RestrictSUIDSGID=true +RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6 AF_NETLINK +CapabilityBoundingSet= +AmbientCapabilities= + +[Install] +WantedBy=multi-user.target diff --git a/deploy/linux/rmm-apt-helper.service b/deploy/linux/rmm-apt-helper.service index 86eec19..a0f40bc 100644 --- a/deploy/linux/rmm-apt-helper.service +++ b/deploy/linux/rmm-apt-helper.service @@ -4,7 +4,10 @@ After=local-fs.target [Service] Type=simple -User=root +# System services default to root. Avoid explicit User=root: systemd 255's +# seccomp setup otherwise drops CAP_SETUID and retains setup inheritable caps. +# Controller verification still requires euid 0, the exact capability sets, +# zero inherited/ambient caps, NNP and the full sandbox below. Group=rmm-agent Environment=RMM_HELPER_CONFIG=/etc/rmm/apt-helper.json ExecStartPre=/usr/local/libexec/rmm-privileged-helper --probe-native @@ -38,9 +41,10 @@ CapabilityBoundingSet=CAP_CHOWN CAP_DAC_OVERRIDE CAP_FOWNER CAP_FSETID CAP_SETGI # Trusted setup needs mount/unshare/fork/capset/prctl/seccomp. There is deliberately # no outer @mount deny; the irreversible worker filter denies it after setup. SystemCallFilter=~@reboot @module @raw-io @swap @clock @debug -# Existing helper clock trust reads adjtimex(modes=0). Mutating adjtimex still -# requires CAP_SYS_TIME, absent from the bounding set; other @clock calls denied. -SystemCallFilter=adjtimex +# glibc implements the read-only adjtimex(modes=0) query via clock_adjtime on +# Ubuntu. Neither syscall can change time without CAP_SYS_TIME (not bounded). +# Keep all other @clock operations denied; never bypass trusted-clock checks. +SystemCallFilter=adjtimex clock_adjtime SystemCallErrorNumber=EPERM ReadWritePaths=/var/lib/dpkg /var/lib/rmm-helper /var/lib/rmm-apt-transaction /usr/share/rmm-mvp-test Restart=on-failure diff --git a/deploy/linux/rmm-helper-cloud.service b/deploy/linux/rmm-helper-cloud.service new file mode 100644 index 0000000..567c0a4 --- /dev/null +++ b/deploy/linux/rmm-helper-cloud.service @@ -0,0 +1,35 @@ +[Unit] +Description=RMM narrowly scoped cloud dev/test root helper +After=time-sync.target + +[Service] +Type=simple +# Implicit root avoids systemd 255 seccomp/setuid capability mutation. +Group=rmm-agent +StateDirectory=rmm-helper +StateDirectoryMode=0700 +RuntimeDirectory=rmm-helper-cloud +RuntimeDirectoryMode=0750 +UMask=0077 +Environment=RMM_HELPER_CONFIG=/etc/rmm-remote/helper-general.json +ExecStart=/usr/local/libexec/rmm-privileged-helper +Restart=no +NoNewPrivileges=true +PrivateTmp=true +PrivateNetwork=true +ProtectSystem=strict +ProtectHome=true +ProtectKernelTunables=true +ProtectKernelModules=true +ProtectControlGroups=true +RestrictSUIDSGID=true +RestrictAddressFamilies=AF_UNIX +CapabilityBoundingSet=CAP_CHOWN CAP_DAC_OVERRIDE CAP_FOWNER CAP_FSETID CAP_SETGID CAP_SETUID CAP_SETPCAP CAP_SETFCAP +AmbientCapabilities= +SystemCallFilter=~@mount @reboot @swap @raw-io @module @clock @debug +# Read-only trusted clock query; glibc may use clock_adjtime. No CAP_SYS_TIME. +SystemCallFilter=adjtimex clock_adjtime +ReadWritePaths=/etc/systemd/system/rmm-mvp-test.service + +[Install] +WantedBy=multi-user.target diff --git a/deploy/remote_client_bootstrap.py b/deploy/remote_client_bootstrap.py new file mode 100644 index 0000000..162e1ec --- /dev/null +++ b/deploy/remote_client_bootstrap.py @@ -0,0 +1,228 @@ +#!/usr/bin/env python3 +"""Create separate clients for the dedicated server; never execute RMM jobs. + +Old VM identities, helpers, services and journals remain untouched. Each new +installation is create-only; failures retain state for inspection, not reenroll. +Server secrets stay on the server. Only a single-use token and public trust +material are transferred over independently verified SSH. +""" +import argparse +import base64 +import hashlib +import inspect +import json +import os +from pathlib import Path +import pwd +import subprocess +import time +import uuid + +import vm_access_check as access + +ROOT = access.ROOT +TENANT = '11111111-1111-4111-8111-111111111111' +DOMAIN = 'discovery.ease-technologies.de' +UNIT = 'rmm-agent-remote.service' + + +def require(value, message): + if not value: + raise RuntimeError(message) + + +def execute(args, **kwargs): + result = subprocess.run(args, capture_output=True, timeout=40, **kwargs) + require(result.returncode == 0, 'command failed; private diagnostics withheld') + return result.stdout + + +def rpc(config, function, payload): + cfg = access.load_config(ROOT/'credentials'/config) + ssh = ['ssh', '-F', '/dev/null', '-T', '-p', cfg.get('port', '22'), + '-o', 'StrictHostKeyChecking=yes', '-o', 'BatchMode=yes', + '-o', 'IdentitiesOnly=yes', '-o', 'ForwardAgent=no', '-o', 'ConnectTimeout=10', + '-i', str(Path(cfg['ssh_key_path']).expanduser()), cfg['username']+'@'+cfg['address'], 'python3 -'] + code = ('import os,json,subprocess,base64,hashlib,ssl,http.client,socket,uuid,pwd\nfrom pathlib import Path\n' + + inspect.getsource(require) + '\n' + inspect.getsource(function) + + '\ntry:\n print(json.dumps('+function.__name__+'('+repr(payload)+')))\n' + 'except Exception as error:\n import traceback\n' + ' print(json.dumps(dict(error="REMOTE_BOOTSTRAP_INCOMPLETE",error_class=type(error).__name__, ' + 'frames=[dict(function=f.name,line=f.lineno) for f in traceback.extract_tb(error.__traceback__)])))\n') + result = json.loads(execute(ssh, input=code.encode())) + if 'error' in result: + # Never expose exception messages, locals, commands or remote stderr. + raise RuntimeError('remote bootstrap incomplete: '+json.dumps({k:result.get(k) for k in ('error_class','frames')})) + return result + + +def server(payload): + root = Path('/opt/rust-discovery') + command = ['docker', 'compose', '--env-file', str(root/'devstate/.env'), + '-f', str(root/'deploy/server.compose.yaml'), 'exec', '-T', 'postgres', + 'psql', '-X', '-qAt', '-v', 'ON_ERROR_STOP=1', '-U', 'postgres', '-d', 'rmm'] + if payload['action'] in ('enroll', 'material'): + raw = None + if payload['action'] == 'enroll': + raw = __import__('secrets').token_hex(32) + digest = hashlib.sha256(raw.encode()).hexdigest() + query = ("INSERT INTO enrollment_tokens(token_hash,tenant_id,expires_at) VALUES('"+digest+ + "','11111111-1111-4111-8111-111111111111',now()+interval '15 minutes');") + subprocess.run(command, input=query.encode(), capture_output=True, check=True) + # This is a public signing-key endpoint, accessed over verified TLS with + # a private loopback reader. No private central key leaves the server. + class HTTPS(http.client.HTTPSConnection): + def connect(self): + self.sock = self._context.wrap_socket(socket.create_connection(('127.0.0.1', 18443), timeout=10), + server_hostname=self.host) + client = HTTPS('rmm-dev.internal', 18443, context=ssl.create_default_context(cafile=str(root/'devstate/pki/ca.pem'))) + client.request('GET', '/api/v1/job-signing-key', headers={'Authorization': 'Bearer '+ + (root/'devstate/operator-a.token').read_text().strip()}) + response = client.getresponse(); require(response.status == 200, 'signing key endpoint rejected') + key = json.loads(response.read()); client.close() + return dict(token=raw, ca=base64.b64encode((root/'devstate/pki/ca.pem').read_bytes()).decode(), key=key) + agent = str(uuid.UUID(payload['agent_id'])) + query = ("SELECT json_build_object('agent_id',agent_id,'asset_id',asset_id,'enrollment_generation',enrollment_generation," + "'assignment_version',assignment_version,'sync_ready',sync_ready,'restore_blocked',restore_blocked," + "'last_contact_at',last_contact_at,'connection_generation',connection_generation,'transport',transport,'inventory_received'," + "EXISTS(SELECT 1 FROM observations o WHERE o.tenant_id=a.tenant_id AND o.agent_id=a.agent_id)) " + "FROM agent_installations a WHERE tenant_id='11111111-1111-4111-8111-111111111111' AND agent_id='"+agent+"';") + result = subprocess.run(command, input=query.encode(), capture_output=True, check=True).stdout.strip() + return json.loads(result) if result else {} + + +def vm(payload): + unit = 'rmm-agent-remote.service' + state = Path('/var/lib/rmm-agent-remote') + config = Path('/etc/rmm-remote') + binary = Path('/usr/local/libexec/rmm-agent-remote') + account = pwd.getpwnam('rmm-agent') + require(os.geteuid() == 0 and account.pw_uid > 0, 'unprivileged agent account required') + if payload['action'] == 'install': + for name in ('rmm-agent.service', 'rmm-helper-dev-test.service', 'rmm-apt-helper.service'): + result = subprocess.run(['systemctl', 'show', name, '-p', 'ActiveState', '--value'], capture_output=True, check=True) + require(result.stdout.strip() == b'inactive', 'old installation is not idle') + target = Path('/etc/systemd/system')/unit + for path in (state, config, binary, target): + require(not path.exists() and not path.is_symlink(), 'existing installation; never reset') + data = base64.b64decode(payload['binary'], validate=True) + require(hashlib.sha256(data).hexdigest() == payload['binary_sha256'] and data[:6] == b'\x7fELF\x02\x01' + and data[18:20] == b'\x3e\x00', 'Linux x86-64 artifact required') + os.umask(0o077) + state.mkdir(mode=0o700); os.chown(state, account.pw_uid, account.pw_gid) + config.mkdir(mode=0o755); config.chmod(0o755) + for path, content, mode, owner in ( + (binary, data, 0o755, 0), (config/'ca.pem', base64.b64decode(payload['ca']), 0o644, 0), + (state/'enroll.token', payload['token'].encode(), 0o600, account.pw_uid), + (config/'agent.env', payload['environment'].encode(), 0o600, 0), + (target, payload['unit'].encode(), 0o644, 0)): + fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, mode) + with os.fdopen(fd, 'wb') as stream: + stream.write(content); stream.flush(); os.fsync(stream.fileno()) + os.chown(path, owner, account.pw_gid if owner else 0) + path.chmod(mode) + subprocess.run(['/lib64/ld-linux-x86-64.so.2', '--list', str(binary)], capture_output=True, check=True) + subprocess.run(['systemd-analyze', 'verify', str(target)], capture_output=True, check=True) + subprocess.run(['systemctl', 'daemon-reload'], capture_output=True, check=True) + return dict(installed=True, uid=account.pw_uid) + if payload['action'] in ('start', 'stop', 'enable'): + subprocess.run(['systemctl', payload['action'], unit], capture_output=True, check=True) + return {} + if payload['action'] == 'identity': + path = state/'identity.json' + if not path.exists(): + return {} + identity = json.loads(path.read_text()) + return {key: identity[key] for key in ('agent_id', 'asset_id')} + require(payload['action'] == 'bind', 'unknown bootstrap action') + require(subprocess.run(['systemctl', 'is-active', unit], capture_output=True).stdout.strip() == b'inactive', 'stop owned client before binding') + path = state/'binding.json' + fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, 0o600) + with os.fdopen(fd, 'w') as stream: + json.dump(payload['binding'], stream) + os.chown(path, account.pw_uid, account.pw_gid) + env = config/'agent.env' + require(env.read_text() == payload['old_environment'], 'bootstrap configuration changed') + env.write_text(payload['environment']); env.chmod(0o600) + (state/'enroll.token').unlink() + return dict(bound=True) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + group = parser.add_mutually_exclusive_group(required=True) + group.add_argument('--provision-vm', action='store_true') + group.add_argument('--resume-vm', action='store_true', help='Resume own retained bootstrap; no enrollment/token reset') + args = parser.parse_args() + target = 'vm' + def client(payload): + return rpc('linux-vm.conf', vm, payload) + os.umask(0o077) + record = ROOT/('devstate/remote-'+target+'.json') + require(record.exists() if args.resume_vm else not record.exists(), 'bootstrap record state does not match requested mode') + artifact = (ROOT/'devstate/rmm-agent-remote').read_bytes() + material = rpc('server.conf', server, dict(action='material' if args.resume_vm else 'enroll')) + cfg = access.load_config(ROOT/'credentials/server.conf') + endpoint = cfg['address'] + ':443' + environment = ('RMM_SERVER_NAME='+DOMAIN+'\nRMM_CONNECT_ADDR='+endpoint+'\n' + 'RMM_ENROLLMENT_TOKEN_FILE=/var/lib/rmm-agent-remote/enroll.token\n') + unit = (ROOT/'deploy/linux/rmm-agent-remote.service').read_text() + if args.resume_vm: + report = json.loads(record.read_text()) + require(report['stage'] in ('installed','passive_observed') and report['domain'] == DOMAIN + and report['binary_sha256'] == hashlib.sha256(artifact).hexdigest() + and report['ca_sha256'] == hashlib.sha256(base64.b64decode(material['ca'])).hexdigest(), + 'retained bootstrap or trust binding differs; no reset') + else: + installed = client(dict(action='install', binary=base64.b64encode(artifact).decode(), + binary_sha256=hashlib.sha256(artifact).hexdigest(), unit=unit, environment=environment, **material)) + report = dict(stage='installed', installed=installed, domain=DOMAIN, unit=UNIT, + binary_sha256=hashlib.sha256(artifact).hexdigest(), ca_sha256=hashlib.sha256(base64.b64decode(material['ca'])).hexdigest()) + def save(): + record.write_text(json.dumps(report, indent=2)); record.chmod(0o600) + save() + started = False + try: + started = True; client(dict(action='start')) + end = time.monotonic()+100 + identity = {} + while time.monotonic() < end: + identity = client(dict(action='identity')) + if identity: + observed = rpc('server.conf', server, dict(action='observe', agent_id=identity['agent_id'])) + if observed.get('inventory_received') and observed.get('last_contact_at'): + break + time.sleep(2) + require(identity and observed.get('inventory_received'), 'native enrollment/inventory not observed') + report.update(identity=identity, passive_observation=observed, stage='passive_observed'); save() + client(dict(action='stop')); started = False + binding = {key: observed[key] for key in ('agent_id','asset_id','enrollment_generation','assignment_version')} + binding.update(tenant_id=TENANT, public_key_hex=material['key']['public_key_hex']) + bound_environment = ('RMM_SERVER_NAME='+DOMAIN+'\nRMM_CONNECT_ADDR='+endpoint+'\n' + 'RMM_JOB_BINDING_FILE=/var/lib/rmm-agent-remote/binding.json\nRMM_JOB_SIGNING_KEY_BOOTSTRAP=1\n') + client(dict(action='bind', binding=binding, old_environment=environment, environment=bound_environment)) + started = True; client(dict(action='start')) + end = time.monotonic()+100 + while time.monotonic() < end: + observed = rpc('server.conf', server, dict(action='observe', agent_id=identity['agent_id'])) + if observed.get('sync_ready') and not observed.get('restore_blocked'): + break + time.sleep(2) + require(observed.get('sync_ready') and not observed.get('restore_blocked'), 'native signed sync gate not ready') + client(dict(action='enable')) + report.update(stage='signed_sync_ready', sync_observation=observed, jobs_executed=False); save() + print('PASS '+target+' direct domain TLS/mTLS, passive inventory and signed Sync; no RMM job executed') + # The user requested a client against the remote server. Leave this new + # unprivileged client running; old installation remains stopped/intact. + started = False + finally: + if started: + client(dict(action='stop')) + + +if __name__ == '__main__': + try: + main() + except Exception: + print('CLIENT_BOOTSTRAP_INCOMPLETE; preserve identities and inspect private state') + raise SystemExit(2) from None diff --git a/deploy/renew_server_tls.py b/deploy/renew_server_tls.py new file mode 100644 index 0000000..c31d082 --- /dev/null +++ b/deploy/renew_server_tls.py @@ -0,0 +1,67 @@ +#!/usr/bin/env python3 +"""Fixed server TLS maintenance. No client identity, grant or job changes.""" +import os +from pathlib import Path +import subprocess +import tempfile + +ROOT = Path('/opt/rust-discovery') + + +def run(args): + return subprocess.run(args, capture_output=True, check=True) + + +def main(): + if os.geteuid() != 0: + raise RuntimeError('root maintenance required') + os.umask(0o077) + pki = ROOT/'devstate/pki' + current = pki/'server.pem' + for path in (ROOT, ROOT/'devstate', pki, ROOT/'devstate/api-pki', current, + ROOT/'devstate/api-pki/server.pem', pki/'ca.pem', pki/'ca.key', + pki/'ca.srl', pki/'server.key'): + if path.is_symlink() or path.stat().st_mode & 0o022: + raise RuntimeError('unsafe PKI path') + api_certificate = ROOT/'devstate/api-pki/server.pem' + if current.read_bytes() == api_certificate.read_bytes() and subprocess.run( + ['openssl', 'x509', '-checkend', '604800', '-noout', '-in', str(current)], + capture_output=True).returncode == 0: + return + run(['openssl', 'x509', '-checkend', '2595600', '-noout', '-in', str(pki/'ca.pem')]) + with tempfile.TemporaryDirectory(prefix='server-renew-', dir=ROOT/'devstate') as folder: + folder = Path(folder) + config = folder/'extensions.cnf' + config.write_text('[server]\nbasicConstraints=critical,CA:FALSE\n' + 'keyUsage=critical,digitalSignature\nextendedKeyUsage=serverAuth\n' + 'subjectAltName=DNS:discovery.ease-technologies.de,DNS:rmm-dev.internal,DNS:localhost\n') + csr = folder/'server.csr' + run(['openssl', 'req', '-new', '-key', str(pki/'server.key'), '-out', str(csr), + '-subj', '/CN=discovery.ease-technologies.de']) + certificate = folder/'server.pem' + run(['openssl', 'x509', '-req', '-in', str(csr), '-CA', str(pki/'ca.pem'), + '-CAkey', str(pki/'ca.key'), '-CAserial', str(pki/'ca.srl'), '-out', str(certificate), + '-days', '30', '-extfile', str(config), '-extensions', 'server']) + run(['openssl', 'verify', '-CAfile', str(pki/'ca.pem'), '-verify_hostname', + 'discovery.ease-technologies.de', str(certificate)]) + data = certificate.read_bytes() + for directory in (pki, ROOT/'devstate/api-pki'): + temporary = directory/'.server-renew.pem' + fd = os.open(temporary, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, 0o600) + with os.fdopen(fd, 'wb') as stream: + stream.write(data); stream.flush(); os.fsync(stream.fileno()) + os.chown(temporary, 10001, 10001) + os.replace(temporary, directory/'server.pem') + # The Rust listeners load certificates at startup. Restart only these own + # services; durable jobs/journals remain in PostgreSQL and on clients. + run(['docker', 'compose', '--env-file', str(ROOT/'devstate/.env'), '-f', + str(ROOT/'deploy/server.compose.yaml'), 'restart', 'api', 'gateway']) + print('Server TLS certificate renewed with unchanged CA and key') + + +if __name__ == '__main__': + try: + main() + except Exception: + print('SERVER_TLS_RENEWAL_FAILED; inspect protected server configuration') + raise SystemExit(1) from None diff --git a/deploy/server-ingress.service b/deploy/server-ingress.service new file mode 100644 index 0000000..6cfa149 --- /dev/null +++ b/deploy/server-ingress.service @@ -0,0 +1,19 @@ +[Unit] +Description=TCP forwarding to loopback-only RMM agent gateway +Requires=docker.service +After=docker.service + +[Service] +ExecStart=/usr/lib/systemd/systemd-socket-proxyd 127.0.0.1:18444 +DynamicUser=true +NoNewPrivileges=true +PrivateTmp=true +ProtectSystem=strict +ProtectHome=true +ProtectKernelTunables=true +ProtectKernelModules=true +ProtectControlGroups=true +RestrictSUIDSGID=true +RestrictAddressFamilies=AF_INET AF_INET6 +CapabilityBoundingSet= +AmbientCapabilities= diff --git a/deploy/server-ingress.socket b/deploy/server-ingress.socket new file mode 100644 index 0000000..999018c --- /dev/null +++ b/deploy/server-ingress.socket @@ -0,0 +1,11 @@ +[Unit] +Description=Public RMM agent TLS ingress (no WebUI) + +[Socket] +ListenStream=0.0.0.0:443 +ListenStream=[::]:443 +BindIPv6Only=ipv6-only +NoDelay=true + +[Install] +WantedBy=sockets.target diff --git a/deploy/server-tls-renew.service b/deploy/server-tls-renew.service new file mode 100644 index 0000000..081c2fe --- /dev/null +++ b/deploy/server-tls-renew.service @@ -0,0 +1,15 @@ +[Unit] +Description=Renew the dedicated RMM server TLS leaf certificate if needed +After=docker.service +Requires=docker.service + +[Service] +Type=oneshot +ExecStart=/usr/bin/python3 -I /opt/rust-discovery/deploy/renew_server_tls.py +UMask=0077 +NoNewPrivileges=true +PrivateTmp=true +ProtectSystem=strict +ProtectHome=true +ReadWritePaths=/opt/rust-discovery/devstate +RestrictAddressFamilies=AF_UNIX diff --git a/deploy/server-tls-renew.timer b/deploy/server-tls-renew.timer new file mode 100644 index 0000000..aa688c5 --- /dev/null +++ b/deploy/server-tls-renew.timer @@ -0,0 +1,10 @@ +[Unit] +Description=Daily check of dedicated RMM server TLS expiry + +[Timer] +OnCalendar=daily +RandomizedDelaySec=30m +Persistent=true + +[Install] +WantedBy=timers.target diff --git a/deploy/server.compose.yaml b/deploy/server.compose.yaml new file mode 100644 index 0000000..7db0526 --- /dev/null +++ b/deploy/server.compose.yaml @@ -0,0 +1,98 @@ +name: rust-discovery-server +services: + postgres: + image: postgres:17.6-bookworm + environment: + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?} + volumes: + - pgdata:/var/lib/postgresql/data + - ../devstate/init.sql:/docker-entrypoint-initdb.d/10-rmm.sql:ro + healthcheck: + test: [CMD-SHELL, "pg_isready -U postgres -d rmm"] + interval: 2s + timeout: 3s + retries: 30 + networks: [backend] + restart: unless-stopped + migrate: + image: rust-discovery-server:local + build: + context: .. + dockerfile: deploy/Dockerfile + command: [migrate] + environment: + MIGRATION_DATABASE_URL: ${MIGRATION_DATABASE_URL:?} + depends_on: + postgres: {condition: service_healthy} + networks: [backend] + gateway: + image: rust-discovery-server:local + user: "10001:10001" + environment: + RMM_PROFILE: development + RMM_DEV_AUTH: "true" + RMM_SERVER_ROLE: gateway + DATABASE_URL: ${DATABASE_URL:?} + RMM_VIEWER_A: ${RMM_VIEWER_A:?} + RMM_VIEWER_B: ${RMM_VIEWER_B:?} + # Same principal registry for permit-time rechecks; this role exposes + # neither login nor administrative HTTP/MCP routes. + RMM_OPERATOR_A: ${RMM_OPERATOR_A:?} + RMM_OPERATOR_B: ${RMM_OPERATOR_B:?} + RMM_DEV_USERNAME: ${RMM_DEV_USERNAME:?} + RMM_DEV_PASSWORD: ${RMM_DEV_PASSWORD:?} + RMM_UI_ORIGIN: https://localhost:18443 + RMM_TLS_DIR: /pki + RMM_JOB_KEY_FILE: /jobs/ed25519.pem + RMM_DEV_ROOT_ENABLED: ${RMM_DEV_ROOT_ENABLED:-false} + RMM_DEV_ROOT_POLICY_FILE: /root-policy/policy.json + ports: ["127.0.0.1:18444:18443"] + volumes: + - ../devstate/pki:/pki:ro + - ../devstate/jobs:/jobs:ro + - ../devstate/root-policy:/root-policy:ro + read_only: true + cap_drop: [ALL] + security_opt: [no-new-privileges:true] + depends_on: + migrate: {condition: service_completed_successfully} + networks: [backend, ingress] + restart: unless-stopped + api: + image: rust-discovery-server:local + user: "10001:10001" + environment: + RMM_PROFILE: development + RMM_DEV_AUTH: "true" + RMM_SERVER_ROLE: api + DATABASE_URL: ${DATABASE_URL:?} + RMM_VIEWER_A: ${RMM_VIEWER_A:?} + RMM_VIEWER_B: ${RMM_VIEWER_B:?} + RMM_OPERATOR_A: ${RMM_OPERATOR_A:?} + RMM_OPERATOR_B: ${RMM_OPERATOR_B:?} + RMM_DEV_USERNAME: ${RMM_DEV_USERNAME:?} + RMM_DEV_PASSWORD: ${RMM_DEV_PASSWORD:?} + RMM_UI_ORIGIN: https://localhost:18443 + RMM_TLS_DIR: /pki + RMM_JOB_KEY_FILE: /jobs/ed25519.pem + RMM_DEV_ROOT_ENABLED: ${RMM_DEV_ROOT_ENABLED:-false} + RMM_DEV_ROOT_POLICY_FILE: /root-policy/policy.json + RMM_WEB_DIR: /web + ports: ["127.0.0.1:18443:18443"] + volumes: + - ../devstate/api-pki:/pki:ro + - ../devstate/jobs:/jobs:ro + - ../devstate/root-policy:/root-policy:ro + - ../web/dist:/web:ro + read_only: true + cap_drop: [ALL] + security_opt: [no-new-privileges:true] + depends_on: + migrate: {condition: service_completed_successfully} + networks: [backend, ingress] + restart: unless-stopped +networks: + backend: {internal: true} + ingress: +volumes: + pgdata: diff --git a/deploy/vm_controller_diagnostic.py b/deploy/vm_controller_diagnostic.py new file mode 100644 index 0000000..d3d27f3 --- /dev/null +++ b/deploy/vm_controller_diagnostic.py @@ -0,0 +1,158 @@ +#!/usr/bin/env python3 +"""Explicit bootstrap diagnosis in the installed APT unit; never a job/probe. + +Temporarily replaces only service commands with a read-only controller check. +All sandbox settings remain in force. No daemon, native probe, package manager, +grant or approval is invoked. Refuses active services, drop-ins or unresolved +consumption. Removes only its own exact temporary files and restores the unit. +""" +import argparse +import hashlib +import inspect +import json +import os +from pathlib import Path +import subprocess +import uuid + +import vm_job_bootstrap as bootstrap +from vm_passive_test import require, remote_python + +ROOT = bootstrap.ROOT +# Reviewed pre-fix unit from the preserved 2026-11-12 VM deployment. Accepting +# this exact version permits diagnosis before the rebuilt helper is deployed. +PRE_FIX_UNIT_SHA256 = '87c2fa242a604fbb9edb5612dd0ef1e703a362d8b465cb97fb3b7ccb5f781f36' + +CHECK = '''import json,runpy +from pathlib import Path +codes = { + 'ROOT_REQUIRED', 'APT_CONTROLLER_NNP', 'APT_CONTROLLER_OUTER_FILTER', + 'APT_CONTROLLER_CAPABILITIES', 'APT_CONTROLLER_INHERITED_CAPABILITIES', + 'APT_CONTROLLER_UNIT', 'APT_CONTROLLER_READONLY_SYSTEM', + 'APT_CONTROLLER_WRITE_TARGET_REQUIRED', 'APT_CONTROLLER_MOUNTINFO', + 'APT_CONTROLLER_EXTRA_WRITE_MOUNT', +} +try: + module=runpy.run_path('/usr/lib/rmm-apt-transaction/apt_transaction.py',run_name='controller_diagnostic') + try: + module['verify_controller_profile']() + code='passed' + except module['Veto'] as error: + code=str(error) if str(error) in codes else 'UNCLASSIFIED_VETO' + status=dict(line.split(':',1) for line in Path('/proc/self/status').read_text().splitlines() if ':' in line) + fields={key:status[key].strip() for key in ('NoNewPrivs','Seccomp','CapEff','CapPrm','CapBnd','CapInh','CapAmb')} + print('RMM_CONTROLLER_DIAGNOSTIC='+json.dumps(dict(code=code,status=fields)),flush=True) +except Exception: + print('RMM_CONTROLLER_DIAGNOSTIC='+json.dumps(dict(code='DIAGNOSTIC_FAILED')),flush=True) +''' + + +def remote_diagnose(payload): + import sqlite3 + os.umask(0o077) + unit = 'rmm-apt-helper.service' + base = Path('/var/lib/rmm-apt-transaction') + unit_path = Path('/etc/systemd/system') / unit + dropdir = Path(str(unit_path) + '.d') + dropin = dropdir / '90-controller-diagnostic.conf' + script = base / ('controller-diagnostic-' + payload['id'] + '.py') + + def run(args): + return subprocess.run(args, capture_output=True, text=True, timeout=40, check=True).stdout + + def count(): + with sqlite3.connect('file:/var/lib/rmm-helper/consumption.sqlite?mode=ro', uri=True) as db: + return db.execute('SELECT count(*) FROM consumed').fetchone()[0] + + def create(path, content): + fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, 0o600) + with os.fdopen(fd, 'w') as stream: + stream.write(content) + + require(os.geteuid() == 0, 'root bootstrap required') + require(count() == 0, 'nonempty root ledger; no diagnostic start') + for name in ('rmm-agent.service', 'rmm-helper-dev-test.service', unit): + require(run(['systemctl', 'show', name, '-p', 'ActiveState', '--value']).strip() == 'inactive', + 'service is not idle; no stop performed') + for path, pins in ((unit_path, payload['unit_sha256']), + (Path('/usr/lib/rmm-apt-transaction/apt_transaction.py'), [payload['provider_sha256']])): + require(not path.is_symlink() and path.stat().st_uid == 0 and path.stat().st_mode & 0o022 == 0 + and hashlib.sha256(path.read_bytes()).hexdigest() in pins, 'installed source mismatch') + require(base.is_dir() and not base.is_symlink() and base.stat().st_uid == 0 + and base.stat().st_mode & 0o777 == 0o700, 'unsafe provider store') + require(not run(['systemctl', 'show', unit, '-p', 'DropInPaths', '--value']).strip(), 'existing unit overrides') + require(not dropdir.exists(), 'existing drop-in directory; no changes') + require(not script.exists() and not script.is_symlink(), 'diagnostic script already exists') + require(not (base / 'native-readiness.json').exists(), 'existing readiness; inspect before diagnosis') + override = ('[Service]\nType=oneshot\nRestart=no\nExecStartPre=\n' + 'ExecStartPre=/usr/bin/python3 -I ' + str(script) + '\nExecStart=\nExecStart=/usr/bin/true\n') + if payload['implicit_root']: + # System services default to root. Clear only the redundant explicit + # User=root; keep Group, NNP, bounding/ambient sets and all filters. + override += 'User=\n' + made_script = made_dir = made_dropin = False + try: + create(script, payload['check']); made_script = True + dropdir.mkdir(mode=0o755); made_dir = True + create(dropin, override); made_dropin = True + run(['systemctl', 'daemon-reload']) + run(['systemctl', 'start', unit]) + # A completed oneshot clears InvocationID. Match our unique marker in + # the unit journal instead of relying on a live process or stale logs. + logs = run(['journalctl', '--no-pager', '-u', unit, '-n', '50', '-o', 'cat']) + prefix = 'RMM_CONTROLLER_DIAGNOSTIC_' + payload['id'] + '=' + records = [json.loads(line.split('=', 1)[1]) for line in logs.splitlines() + if line.startswith(prefix)] + require(len(records) == 1, 'missing or ambiguous diagnostic result') + report = records[0] + finally: + # Never stop a daemon: the override runs a finite check and /usr/bin/true. + require(run(['systemctl', 'show', unit, '-p', 'ActiveState', '--value']).strip() + in ('inactive', 'failed'), 'unexpected active unit; inspect manually') + if made_dropin: + require(dropin.read_text() == override and not dropin.is_symlink(), 'diagnostic override changed') + dropin.unlink() + if made_dir: + dropdir.rmdir() + if made_script: + require(script.read_text() == payload['check'] and not script.is_symlink(), 'diagnostic script changed') + script.unlink() + run(['systemctl', 'daemon-reload']) + require(count() == 0 and not (base / 'native-readiness.json').exists(), 'unexpected effect evidence') + require(not run(['systemctl', 'show', unit, '-p', 'DropInPaths', '--value']).strip(), 'override remains') + return dict(controller=report, restored=True, root_consumed=0, native_readiness=False, + package_effects=False, rmm_jobs_executed=False) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--diagnose-installed-profile', action='store_true', required=True) + parser.add_argument('--implicit-root', action='store_true', help='Test default-root identity with otherwise identical sandbox') + args = parser.parse_args() + payload = dict(id=uuid.uuid4().hex, check=CHECK, + unit_sha256=[PRE_FIX_UNIT_SHA256, hashlib.sha256((ROOT/'deploy/linux/rmm-apt-helper.service').read_bytes()).hexdigest()], + provider_sha256=hashlib.sha256((ROOT/'tools/apt-transaction/apt_transaction.py').read_bytes()).hexdigest()) + payload['check'] = CHECK.replace('RMM_CONTROLLER_DIAGNOSTIC=', + 'RMM_CONTROLLER_DIAGNOSTIC_' + payload['id'] + '=') + payload['implicit_root'] = args.implicit_root + code = ('import os,json,hashlib,subprocess\nfrom pathlib import Path\n' + 'def require(value,message):\n if not value: raise RuntimeError(message)\n' + + inspect.getsource(remote_diagnose) + '\ntry:\n print(json.dumps(remote_diagnose(' + repr(payload) + + ')))\nexcept Exception:\n print(json.dumps(dict(error="BOOTSTRAP_DIAGNOSTIC_INCOMPLETE")))\n') + with bootstrap.connection() as (ssh, target, env): + result = json.loads(remote_python(ssh, target, env, code)) + require('error' not in result, 'bootstrap diagnostic incomplete; inspect unit state before continuing') + directory = ROOT/'devstate/controller-diagnostic' + directory.mkdir(mode=0o700, exist_ok=True) + fd = os.open(directory/(payload['id']+'.json'), os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600) + with os.fdopen(fd, 'w') as stream: + json.dump(result, stream, indent=2) + print(json.dumps(result)) + + +if __name__ == '__main__': + try: + main() + except Exception: + print('BOOTSTRAP_DIAGNOSTIC_INCOMPLETE; private details withheld') + raise SystemExit(2) from None diff --git a/deploy/vm_mvp_acceptance.py b/deploy/vm_mvp_acceptance.py index 0b30139..87458cc 100644 --- a/deploy/vm_mvp_acceptance.py +++ b/deploy/vm_mvp_acceptance.py @@ -73,7 +73,12 @@ def now(): def timestamp(value): require(isinstance(value, str), 'timestamp_type') - parsed = dt.datetime.fromisoformat(value.replace('Z', '+00:00')) + # Rust/chrono emits RFC3339 nanoseconds. Python 3.10 accepts only up to + # microseconds in fixed fractional widths. Retain the raw evidence; pad or + # truncate only the comparison, including variable-width PostgreSQL times. + comparable = re.sub(r'\.(\d+)(?=Z$|[+-]\d{2}:\d{2}$)', + lambda match: '.'+(match[1]+'000000')[:6], value) + parsed = dt.datetime.fromisoformat(comparable.replace('Z', '+00:00')) require(parsed.utcoffset() is not None, 'timestamp_timezone_required') return parsed diff --git a/docs/development.md b/docs/development.md index 17b64a6..645b1df 100644 --- a/docs/development.md +++ b/docs/development.md @@ -1,6 +1,16 @@ # Linux-first-Entwicklung und reale VM-Abnahme -Stand: 2026-11-12 · Spezifikation 1.5. Dieses Dokument beschreibt verbindliche Entwicklungsregeln und einen grundsätzlich **geplanten** Ablauf. Tatsächlich ausgeführte Prüfungen stehen ausdrücklich im Nachweisabschnitt am Ende; die übrigen Beispiele sind keine Testergebnisse. Tatsächlicher Implementierungsstand wird separat geführt. +Stand: 2026-11-13 · Spezifikation 1.8. **Windows-Override:** Entwicklung und native +Tests auf der neuen Windows-11-VM sind ausdrücklich parallel erlaubt, unabhängig +von der noch offenen Linux-MVP-Abnahme. Die nachstehenden älteren Wartevorgaben +sind hierfür überstimmt; keine Windows-Pflicht zur Linux-Abnahme. +**Topologieoverride:** Dieses Notebook +ist ausschließlich Entwicklungsrechner, weder RMM-Server noch RMM-Client. +Aktueller Client ist die Cloud-Test-VM, endgültiger Server der festgelegte +Cloudserver. Clients verbinden sich ausgehend direkt dorthin. Aktueller Vertrag und +Deploymentnachweise: [server-deployment.md](server-deployment.md). +Die folgenden PC-Server-/Reverse-Tunnel-Abläufe und Nachweise sind historisch. +TLS/mTLS, Credentialschutz, Linux-first und WebUI-Plangenehmigung gelten weiter. ## Ergänzende Userfreigabe und lokale Browserprüfung (2026-11-12) diff --git a/docs/handover.md b/docs/handover.md index 2b1956a..33298e1 100644 --- a/docs/handover.md +++ b/docs/handover.md @@ -1,5 +1,21 @@ # Übergabe / Entwicklungspause — 2026-11-12 +**Historische Übergabe. Wiederaufnahme am 2026-11-13 ausdrücklich beauftragt.** +Die lokale Servertopologie wurde inzwischen durch den dedizierten Internetserver +ersetzt; aktueller Zustand und Zugänge: [server-deployment.md](server-deployment.md). +Der unten genannte Skript-/SHA-Konflikt ist korrigiert. Alte Nachweise bleiben +historisch; neue getrennte Testidentitäten sind keine Wiederherstellung der alten +Serverhistorie. Aktueller Prüfstand: [implementation-status.md](implementation-status.md). + +**Neuester Cloud-Stand 2026-11-13:** Root-Testdienst eingerichtet/gestartet/gestoppt, +jeweils tatsächlich separat WebUI-genehmigt und auf VM bestanden. Erste APT- +Acceptance `failed / HOOK_NOT_HANDED_OFF`, APT 100 vor Hookübergabe, Paketbestand +unverändert. Kein Wiederholungsversuch; Create-once-Marker und Ledger erhalten. +Root-Testpolicy geschlossen, APT-Helper gestoppt/deaktiviert; Cloud-Agent aktiv, +Notebook ohne Client. Cloud-Controlpfad-Maskierungsfix nur im Quellcode/lokal +geprüft, neue VM-Readiness und sichere Weiterführung des gespeicherten Fehlversuchs +offen. Details und Belege in [server-deployment.md](server-deployment.md#root--apt-abnahmelauf-2026-11-13). + **Auf Userwunsch pausiert. Linux-MVP M0–M5 ausdrücklich NICHT vollständig abgenommen; keine Produktionsfreigabe.** Dieser Durchgang sichert Dokumentation und prüft veröffentlichbare Quellen. Keine Entwicklung, Builds, Tests, diff --git a/docs/implementation-status.md b/docs/implementation-status.md index 51f4508..299fa55 100644 --- a/docs/implementation-status.md +++ b/docs/implementation-status.md @@ -1,6 +1,215 @@ # Tatsächlicher Implementierungsstand -## ENTWICKLUNG PAUSIERT auf Useranweisung — Übergabe 2026-11-12 +## APT-Diagnose, erster Folgeschritt — 2026-11-13 + +Tatsächlicher neuer Root-Diagnosejob auf bestehender Cloud-VM, Server weiterhin +`discovery.ease-technologies.de`. Plan/Antrag und separate Genehmigung über reale +WebUI mit sichtbar simuliertem Testprincipal; vor Genehmigung 0/0/0, danach +genau 1 Job/Outbox/Startgrant, Audit mit festem Planhash bestätigt. Ein zunächst +ordnungssensitiver JSON-Objektvergleich stoppte den Browser **vor** Genehmigung; +dasselbe nachweislich noch ausführungslos wartende Gesuch nach Korrektur geprüft +und genehmigt, kein neuer Antrag/Versuch. + +`deploy/linux/apt-diagnostic.py` führte ausschließlich zwei `apt-get --simulate` +Aufrufe aus: ursprüngliche Argumente sowie dieselben ohne `--`-Separator. +Beide **Exit 0**, identische Ausgabehashes, Fixture vom Solver erkannt; keine +Pakettransaktion. Separate Scratchpfade in PrivateTmp; gesamte Dateien des +aktiven Fehlversuchs, Versuchsmarker und dpkg-Status nachher bytegleich. +Der Separator ist als Ursache ausgeschlossen. Das ist **keine** Paketabnahme +und noch kein Nachweis der Ursache des ursprünglichen APT-100-Fehlers. + +Gesamtsnapshot nun **7 succeeded / 1 failed / 1 cancelled; 9/9/8**. Temporäre +Diagnosepolicy beschränkt auf allgemeines Rootskript, genau eine VM und den +simulierten WebUI-Principal, keine Dienst-/Reboot-/APT-Erlaubnis. Noch aktiv, +wird nach Abschluss geschlossen. Sandbox-Fix gebaut; native Prüfung folgt. +Geschützte Belege unter `devstate/cloud-apt-followup/diagnosis/`. +8 Cloud- und 3 Bootstrap-Guards, Node-Syntax und Diffprüfung bestanden. + +Userauftrag: Nach jedem Abnahmeschritt dokumentierte Projektquellen committen +und nach Gitea pushen; private Daten bleiben ausgeschlossen. Erster Push umfasst +auch den bisherigen noch uncommitteten Cloud-/Rootstand. 220 nichtignorierte +Sourcepfade geprüft, kein bestätigter Secretfund; ein Literal ausschließlich +als synthetische Canary im bestehenden Diagnose-Unit-Test klassifiziert. + +## Cloud-Root/Dienste bestanden; APT-Versuch fehlgeschlagen — 2026-11-13 + +Nur bestehende Cloud-Test-VM und `discovery.ease-technologies.de`; Notebook +weiter ausschließlich Entwicklung. Tatsächlich über die WebUI als sichtbar +simulierter Testprincipal beantragt und separat genehmigt: + +| Fester Einzelplan | Tatsächliches VM-Ergebnis | +| --- | --- | +| Root-Skript: vorerzeugten Testdienst einrichten | `succeeded`, Exit 0, exakte Ausgabe und Nachbedingung | +| `rmm-mvp-test.service` starten | `succeeded`, Nachbedingung bestätigt | +| denselben Dienst stoppen | `succeeded`, Dienst anschließend `inactive` | +| APT Native Acceptance: Fixture 1.0 | `failed`, `HOOK_NOT_HANDED_OFF`; **keine Paketabnahme** | + +Jeder Antrag vor Genehmigung persistent `pending_approval` mit **0 Jobs / +0 Outbox / 0 Startgrants**, danach genau **1/1/1**. Alle vier Audits binden +Planhash und `simulated-testprincipal-a`, `dev_test_browser_simulation`, +`testsimulation=true`. Rootplan-Vorbereitung ebenfalls über echte UI-Bedienung; +keine Erweiterung der MCP-Berechtigungen, keine API-/DB-Genehmigung. + +- Neuen Helper kontrolliert auf der VM installiert; alte/neue Agentidentitäten, + Journale, Rootledger-Inode und vorherige Artefakte erhalten. Erster nativer + APT-Readonly-Probe bestand, aber die Daemons starben anschließend an einer + blockierten Zeitabfrage: Ubuntu-glibc verwendet `clock_adjtime` für den + read-only `adjtimex(modes=0)`-Aufruf. Alias eng erlaubt, **kein CAP_SYS_TIME**, + keine abgeschaltete Clockprüfung. Danach neuer nativer Probe, zehn stabile + Daemonprüfungen und gemeinsames gebundenes Ledger ohne Fehler bestanden. + Das anfängliche `completed=true` des alten Spawnchecks war **kein** stabiler + Readinessnachweis; korrigierter Bootstrap wartet jetzt tatsächlich. +- Nonce-/Root-Peer-/Identitäts-/Profil-/Hash-gebundene Controlantworten als + tatsächlicher UID993-Peer geprüft. Beide Helper teilen dieselben Ledger- und + Lock-Inodes; aktueller Server-Signierschlüssel, keine Ledgerneuerzeugung. +- APT-Versuch erreichte echte private Namespaces, Cap-/NNP-/Seccompprüfungen, + readonly Controlmounts und echten APT-Frontend-Lockkonflikt. Danach APT **100**, + kein `hook-armed.json`, keine Acceptance. Elternprozess verglich den gesamten + Paketbaselinezustand unverändert; frisches gespeichertes passives Inventar + bestätigt unveränderte Baseline/Statusfingerprint und Fixture nicht installiert. + Die genaue APT-100-Ursache ist **nicht nachgewiesen**; stdout/stderr des nativen + APT-Prozesses wurden vom bisherigen Provider verworfen. Kein spekulativer Fix + als bestanden ausgegeben, kein zweiter Paketversuch. +- Einmaliger `bootstrap-attempt-rmm-apt-fixture-install-1.0.json`, `active/`, + Grant/Versuch und alle Fehlernachweise erhalten. **4 verbrauchte, abgeschlossene + Rootversuche, 0 offene Rootwirkungen, 0 sticky Syncfehler**, Ledgerintegrität ok. + Install/Update/EnsurePackage/ApplyUpdates bleiben offen; ein neuer Versuch darf + den Create-once-Marker nicht durch Löschen, neue Identität oder Rezeptalias umgehen. +- Nachprüfung fand fehlende Maskierung der neuen `/etc/rmm-remote`- und + `/var/lib/rmm-agent-remote`-Pfade in der bisherigen Paketsandbox. Quellcode + blendet jetzt alte und neue Layouts aus und verweigert sichtbare Inhalte/ + Symlinks. **Lokal geprüft, noch nicht auf VM installiert oder abgenommen.** + Dieser Fix ändert Provider-/Helper-/Runtimehashes und erfordert kontrollierte + Migration mit erhaltenem Ledger/Versuchsmarker und erneute native Readiness. +- Abschließend Testpolicy explizit abgelaufen gesetzt; APT-Helper gestoppt und + deaktiviert, nur seine eigenen Socket-/Proof-Umgebungswerte aus dem gesicherten + Agentdrop-in entfernt. Cloud-Agent und allgemeiner Helper bleiben aktiv. + Abschließend Cloudgerät `online`, signierter Sync `ready`, kein Restoreblock, + keine APT-Capability mehr; Policy tatsächlich abgelaufen, UID10001/0600 geprüft. + Keine Reboots, Systemupdates, Paketinstallation per SSH oder Notebook-Clients. + +Cloud-Gesamtsnapshot nach den vier neuen Versuchen: **6 succeeded / 1 failed / +1 cancelled; 8 Jobs / 8 Outbox / 7 Startgrants; 0 ungeklärte/laufende Jobs**. +Die Werte 4/4/3 im folgenden Basisabschnitt sind historische Zwischenstände. + +Lokale Prüfungen: **58 APT-Pythontests**, **8 Cloud-Guards**, **28 MVP-Guards**, +**3 Bootstrap-Guards** bestanden. Helpertests nach Clockprofiländerung: +**25 Library / 3 Binary / 20 Sync** bestanden; separater Lauf nach dem +Cloud-Controlpfad-Fix ebenfalls **25 / 3 / 20 bestanden**. +Initiale Container-Testaufrufe ohne Fixturemount bzw. `/tmp/opencode` scheiterten; +vollständiger Lauf mit readonly Quellen/Fixtures und privatem tmpfs bestand. +Kein VM-Nachweis aus diesen Containerläufen abgeleitet. + +Werkzeuge, private Belegpfade und konkrete Fortsetzungsgates: +[server-deployment.md](server-deployment.md#root--apt-abnahmelauf-2026-11-13). +Linux-MVP weiterhin nicht vollständig abgenommen; kein Commit/Push. + +## Cloud-MVP-Basisjobstrecke real nachgewiesen — 2026-11-13 + +Ausschließlich bestehende Cloud-VM als Client, endgültiger Server +`discovery.ease-technologies.de`, Notebook nur Entwicklung. Neuer Cloudadapter +`deploy/cloud_mvp_acceptance.py` und tatsächliche UI-Bedienung +`deploy/browser/cloud_approve.cjs`; weder Enrollment noch lokaler Executor, +direkte API-/DB-Genehmigung oder automatischer Ausführungsretry. + +- **Hello World auf WSS und HTTPS-Long-Polling** erfolgreich, jeweils eigener + MCP-Plan/Antrag, `pending_approval` mit gemessenen 0/0/0, tatsächliche simulierte + WebUI-Genehmigung und exakt ein Job/Outbox/Startgrant. Exit 0, exakte Ausgabe + und Nachbedingung auf der tatsächlichen unprivilegierten Cloud-VM bestätigt. +- **Live-Inventur** separat über die WebUI genehmigt, Erhebung neuer als der + gebundene Planbeginn; keine Tarnung als passives Inventar. Nativer Job war + erfolgreich, während der Python-3.10-Verifier Rust-Nanosekunden zunächst nicht + verarbeiten konnte. Parser korrigiert, vorhandenen Nachweis lesend bestätigt; + kein neuer Versuch oder erneute Wirkung. +- **Abbruch vor künftigem Start:** eigener genehmigter Plan, MCP-Abbruch, + `cancelled` und 0 Startgrants. Kein Nachweis eines laufenden Installerabbruchs. +- Insgesamt **3 succeeded / 1 cancelled**, **4 Jobs / 4 Outbox / 3 Grants**, + keine ungeklärten/laufenden Jobs. Alle Genehmigungen mit festem Planbezug, + Testprincipal, `approval_origin=dev_test_browser_simulation`, `testsimulation=true`. +- **MCP-Tenantgrenze** für Gerät und Job belegt; erneutes Submit derselben + Pläne/Schlüssel erzeugt keine neuen Operationen/Jobs. +- **Gateway-Wiederanlauf:** HTTPS-Verwaltungssitzung blieb gültig; anfängliche + Generationserhöhungserwartung für diese persistente HTTPS-Sitzung lief ins + Testlimit. Tatsächlichen WSS-Reconnect anschließend separat gemessen: + höhere Generation, frischer Heartbeat, erfolgreicher signierter Sync, + unveränderte 4/4/3. Agent abschließend wieder auf WSS. +- **5 neue Cloud-Guards**, **28 bestehende MVP-Guards**, **3 Bootstrap-Guards** + bestanden; Node-Syntaxprüfung bestanden. In diesem Abschnitt keine Rustquellen + geändert, keine neue Rust-/Frontend-Gesamttestbehauptung. + +Einzelbelege/ausgeführte Befehle und Grenzen: +[server-deployment.md](server-deployment.md). Root-/APT-/Reboot-/Offline-/ACK- +Fault-Abnahmen und vollständiges Linux-MVP weiterhin offen. Keine Produktions- +freigabe, kein Commit/Push. + +## Wiederaufnahme und dedizierter Server — 2026-11-13 + +Useroverride: Entwickler-PC kein RMM-Server mehr; dedizierter Internetserver mit +`discovery.ease-technologies.de`. Spezifikation **1.7**. **Neueste Userkorrektur:** +Notebook ausschließlich Entwicklung, kein RMM-Client. Aktueller Client ist die +Cloud-VM, der festgelegte Cloudserver ist endgültig. Tatsächliche Einrichtung, +Sicherheitsgrenzen, Start-/Zugangspfade und offene Gates: +[server-deployment.md](server-deployment.md). Die darunterstehende Pause ist historisch. + +- Server nativ auf Ubuntu 26.04/aarch64 gebaut und gestartet, PostgreSQL frisch + migriert. API/Gateway als UID 10001, Dockerports ausschließlich Loopback, + PostgreSQL intern. Öffentlich nur Agent-TLS über separaten TCP-Ingress, keine + Dev-Anmeldung/UI/MCP. Privater WebUI-Login über SSH-Tunnel geprüft. +- Hostkey vom User bestätigt, bestehender SSH-Key funktioniert; Passwortlogin + deaktiviert und Key-Zugang erneut geprüft. Hostfirewall nur SSH/TLS. +- Cloud-Test-VM (x86-64): neue getrennte Agentidentität direkt am Server, + mTLS-WSS, Inventar/frische Heartbeats und signierter Sync bestanden. + Ein zunächst eingerichteter Notebook-Client wurde nach Userkorrektur gestoppt, + deaktiviert und deinstalliert; Geräteidentität über die WebUI widerrufen. + Nur Cloud-VM als aktiver Client; widerrufene Notebook-Historie erhalten. + Kein Gerät in B; 0 Jobs/Outbox/Startgrants. Alte VM-Identität, + Journale und gestoppte Helper unverändert erhalten. Keine Produktionsfreigabe. +- Konfigurierbarer, streng validierter `RMM_SERVER_NAME` ersetzt feste DNS-Namen + in sämtlichen Agenttransporten einschließlich Rotation und Signierbootstrap. + Öffentlicher Gateway bietet ausschließlich mTLS-gebundenen Signierschlüsselbezug; + kein Cookie-/Bearerersatz und keine administrativen Routen. +- Bekannter Skript-/SHA-Konflikt korrigiert, Python- und Browserpin konsistent. + Zusätzlicher Guard prüft beide Pins gemeinsam, bevor eine native UI-Genehmigung + überhaupt versucht wird. +- APT-Controllerursache auf tatsächlicher VM diagnostiziert: unter systemd 255 + entfernt explizites `User=root` CAP_SETUID aus E/P und hinterlässt Setup-Caps + in I. Default-Root im unverändert strengen Schutzprofil besteht alle bisherigen + Controllerprüfungen. Quelle der APT-Unit korrigiert und gebaut; die temporäre + Diagnosekonfiguration ist entfernt. **Keine dauerhafte Umstellung des alten + VM-APT-Helfers, keine neue Native-Readiness oder Paket-Acceptance.** +- Native Erstinstallation des neuen VM-Clients hatte Dateimodusfehler (Exit 203). + Eigene neue Dateimodi unter Hashprüfung korrigiert und denselben Bootstrap + fortgesetzt; Regression ergänzt. Keine Identität neu erzeugt, um einen Fehler + zu verbergen. Neuer Client auf VM als Systemdienst aktiv. Notebook-Userdienst + entfernt, lokales Binary entfernt, private Journalhistorie archiviert. Lokalen + Installationspfad aus Bootstrapwerkzeug entfernt. + +Tatsächlich ausgeführte lokale Prüfungen dieses Durchgangs, getrennte Suites: + +- `python3 tests/vm_mvp_guards.py`: **28 bestanden**. +- Python-APT-Unittest-Discovery: **56 bestanden**. +- `python3 tests/test_remote_client_bootstrap.py`: **3 bestanden**, einschließlich + Verweigerung der entfernten Notebook-Installationsoption; 4 neue Pythondateien + zusätzlich per AST geparst. +- `npm run typecheck`, `npm test`, `npm run build`: erfolgreich, **23 UI-Unit-Tests**. + Keine neue browsergesteuerte Jobgenehmigung oder Browser-Gesamtabnahme behauptet. +- Im isolierten Docker-Build mit gepinnter Rust-Toolchain: + `cargo fmt --all --check` bestanden; + Clippy Helper/Agent/Server all-targets mit `-D warnings` bestanden. + Helper-Suites **25 Library / 3 Binary / 20 Sync** bestanden; + Agent-Suites **24 Binary / 8 Rotation / 5 HTTPS / 18 Sync** bestanden. + Gemeinsame eingebundene Tests nicht als unterschiedliche Featureabnahmen addieren. + Tests benötigten das vorhandene Testfixture-Elternverzeichnis `/tmp/opencode` + im isolierten Container; erster Aufruf ohne dieses Verzeichnis scheiterte, + danach mit privatem tmpfs bestanden. Kein Eingriff in Host-/VM-Paketzustand. +- Beide Releasebinaries für Server/Agent gebaut; Server zusätzlich nativ ARM64 + auf dem neuen Server. Sourcehash-Abgleich und externer TLS-/Port-/Routennachweis + in der Deploymentdokumentation. ARM64-Agenten bleiben unfreigegeben. + +M0–M5 weiterhin offen, insbesondere aktive UI-genehmigte Job-/Root-/APT-/Fehler- +abnahmen auf dem neuen Bestand. Kein Commit/Push ausgeführt. + +## Historisch: Entwicklung pausiert — Übergabe 2026-11-12 Kompakter Einstieg, bekannte ungeprüfte Snapshotfehler und Fortsetzungsgates: [handover.md](handover.md). Die nachfolgenden Worker-Nachweise bleiben erhalten. diff --git a/docs/project-decisions.md b/docs/project-decisions.md index de3aad7..7800c5e 100644 --- a/docs/project-decisions.md +++ b/docs/project-decisions.md @@ -1,6 +1,38 @@ # Verbindliche Projektentscheidungen -Stand: **2026-11-12**, Spezifikation **1.5** (`Rust_RMM_Implementierungsspezifikation.md`). Die ausdrücklichen normativen Entscheidungen in Kapitel 0 haben Vorrang vor früheren Architekturannahmen. Version 1.4 führte Linux-first ein; 1.5 dokumentiert die neuen Userentscheidungen zur dev/test-Browsersimulation und zum MVP ohne RustDesk. Dieses Dokument fasst Entscheidungen zusammen und behauptet keinen Implementierungsstand. +Stand: **2026-11-13**, Spezifikation **1.8** (`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. + +## Windows parallel auf ausdrücklichen Userwunsch (2026-11-13) + +- Windows 11 darf jetzt parallel entwickelt/nativ getestet werden, obwohl die + Linux-MVP-Abnahme noch offen ist. Dies überstimmt ausschließlich die frühere + Wartepflicht; Linux-Abnahme bleibt eigenständig und wird nicht vorgetäuscht. +- Windows-Gast auf dem Notebook ist ein eigenes Testgerät. Notebook-Host bleibt + Entwicklungsrechner ohne RMM-Agenten. Endgültiger Server bleibt unverändert. +- User wünscht ein PowerShell-Bootstrap-Skript mit Reverse-Tunnel zum Cloudserver. + Eng begrenzter separater Tunnelzugang, nur Loopbacklistener, eigener temporärer + Schlüssel; keine Weitergabe des Notebook-Hauptschlüssels. SSH-Hostprüfung gilt + auch für den neuen Windows-Gast. Installation/Ausführung noch nicht nachgewiesen. +- RMM-Jobs auf Windows weiterhin nur nach festem WebUI-genehmigtem Plan. + +## Serverumzug auf ausdrücklichen Userwunsch (2026-11-13) + +- Dieses Notebook ausschließlich zur Entwicklung nutzen: weder RMM-Server noch + installierter/enrollter RMM-Client. Ausdrückliche Userkorrektur nach der + vorübergehenden Clientinstallation, die gestoppt/deinstalliert und widerrufen wurde. +- Aktueller Testaufbau: Cloud-Test-VM als Client, endgültiger Cloudserver + `discovery.ease-technologies.de` als Server. Backend, PostgreSQL und TLS dort; + Cloud-VM und später beauftragte weitere Geräte verbinden sich direkt ausgehend. +- Frühere lokale Docker-/Reverse-SSH-Topologie ist historisch überstimmt. + Dockerports bleiben Loopback; Datenbank nicht veröffentlichen. Separater + öffentlicher TLS-Ingress, keine öffentliche Dev-Anmeldung. Verwaltung zunächst + nur über SSH-Tunnel, bis Domain/öffentliche Anmeldung sicher eingerichtet sind. +- Root ausschließlich Bootstrap, unprivilegierter Anwendungsdienst. Keine + Ausnahme von TLS/mTLS, Mandantengrenzen oder WebUI-Jobgenehmigung. +- Der User hat die Neuerzeugung des nicht verfügbaren alten lokalen Serverstands + erlaubt. Neuer Testbestand ist keine Wiederherstellung alter Historie oder + Vertrauenskontinuität; vorhandene VM-Identitäten/Journale bleiben erhalten. +- Details, Konfigurationslücken und reale Nachweise: [server-deployment.md](server-deployment.md). ## Produkt und Ausbaustufen @@ -60,6 +92,10 @@ Die vollständigen Limits und Plattformabnahmen stehen in der Spezifikation. ARM ## Verbindlicher lokaler Entwicklungsweg +**Historisch seit 2026-11-13:** Die folgende PC-Servertopologie wurde durch den +oben dokumentierten ausdrücklichen Serverumzug ersetzt. Credential-, TLS- und +Genehmigungsregeln gelten weiterhin. + - Regeln für alle AIs: `AGENTS.md`; geplanter, nicht getesteter Ablauf und Nachweisgates: `docs/development.md`. - Server lokal in Docker auf dem Entwickler-PC; veröffentlichte Ports ausschließlich Loopback, insbesondere `127.0.0.1:18443`. PC initiiert SSH zur VM mit `-N -T -o ExitOnForwardFailure=yes -o ServerAliveInterval=30 -o ServerAliveCountMax=3 -R 127.0.0.1:18443:127.0.0.1:18443`. SSH-Hostschlüssel vorher verifizieren, keine öffentliche Forward-Bindung. - VM-Agent verbindet sich ausgehend über VM-Loopback. TLS bleibt Ende-zu-Ende mit DNS SAN `rmm-dev.internal`; auf der VM `/etc/hosts`: `127.0.0.1 rmm-dev.internal`, alternativ getesteter Connect-Override unter Erhalt von SNI/Namensprüfung. Dev-CA vertrauen, niemals ungültige Zertifikate akzeptieren. SSH nur Dev/bootstrap, kein Ersatz für Enrollment/mTLS, RMM-Autorisierung oder Genehmigung. diff --git a/docs/server-deployment.md b/docs/server-deployment.md new file mode 100644 index 0000000..61bfa10 --- /dev/null +++ b/docs/server-deployment.md @@ -0,0 +1,391 @@ +# Dedizierter RMM-Server + +Stand: 2026-11-13 · Spezifikation 1.7 · Linux-MVP weiterhin nicht abgenommen. + +## Verbindlicher Auftrag + +Der User ersetzt die bisherige lokale Servertopologie durch den dedizierten +Internetserver **88.99.80.202**, Domain **discovery.ease-technologies.de**. +`root` ist ausschließlich SSH-Bootstrapzugang; +der RMM-Anwendungsdienst soll unprivilegiert laufen. **Endgültiger Entwicklungs- +und Testaufbau laut neuester Userkorrektur:** Cloud-Test-VM als Client, dieser +Cloudserver als Server, dieses Notebook ausschließlich zur Entwicklung. +Hier keinen RMM-Client installieren, enrollen oder betreiben. Die frühere Aussage +zum lokalen Notebook-Client ist überstimmt. Cloud-VM und später beauftragte +weitere Agenten verwenden diesen Server direkt ausgehend. Ein +PC→Test-VM-Reversetunnel gehört nicht mehr zum vorgesehenen Verbindungsweg. + +Die Maschine ist aus dem Internet erreichbar. Öffentlich nur ausdrücklich +eingerichtete Endpunkte anbieten: Agent-TLS mit geprüfter Serverkette und nach +Enrollment mTLS; keine öffentliche Dev-Anmeldung oder Datenbank. Dockerports +auch dort nur Loopback, PostgreSQL ohne Portveröffentlichung. Ein separater +öffentlicher TLS-Ingress darf nur die dafür vorgesehenen Agentfunktionen +erreichbar machen. Die Verwaltungsoberfläche bleibt zunächst über SSH-Tunnel +zugänglich, bis Domain und sichere öffentliche Anmeldung feststehen. + +TLS-Verifikation niemals abschalten. TCP-Connect-Overrides dürfen weder SNI noch +Zertifikatsnamensprüfung ändern. Root-SSH ersetzt keine Geräteidentität oder +Anwendungsauthentisierung. Jeder RMM-Job bleibt bis zur interaktiven WebUI- +Genehmigung seines unveränderlichen Plans `pending_approval`; die bekannte +dev/test-Browsersimulation ist keine öffentliche Produktionsanmeldung. + +## Konfiguration und Datenbestand + +- Server-SSH-Daten lokal in `credentials/server.conf`, Modus 0600 im + gitignorierten Verzeichnis `credentials/` mit Modus 0700. Keine Schlüssel oder + Tokens in Git, Chat, Kommandoargumenten oder Logs. +- Der alte Serverstand befindet sich auf einem nicht erreichbaren anderen PC. + Der User hat die Neuerzeugung ausdrücklich erlaubt. Neue CA, Zugangsdaten und + Datenbank bilden einen neuen Testbestand; dies stellt die alte Historie und + Vertrauenskette nicht wieder her. Bestehende VM-Identitäten/Journale erhalten. +- Domain vom User festgelegt: `discovery.ease-technologies.de`; DNS zeigte bei + der Prüfung auf den zugewiesenen Server. TLS mit eigener Projekt-CA ist + eingerichtet. Öffentliche WebUI/OIDC bleiben **not_configured**; die + dev/test-WebUI ist ausschließlich über SSH erreichbar. +- Lokale Entwicklungsartefakte können auf dem Notebook gebaut werden; dort + läuft nach dem Umzugsauftrag kein RMM-Server mehr. Neue private Schlüssel und + Daten dürfen ausschließlich geschützt zum vorgesehenen Server übertragen + werden. Agenten erhalten nur öffentliche CA, eigenes Enrollmentmaterial und + ihre eigene Geräteidentität, keine privaten zentralen Schlüssel. + +## Tatsächlich ausgeführt + +- Neuer lokaler Testbestand vor dem Umzugsauftrag erzeugt; Docker-Releasebuild, + Migrationen und CA-verifizierter Healthcheck erfolgreich. Kurzzeitig Server + ausschließlich auf `127.0.0.1:18443`, PostgreSQL ohne veröffentlichten Port. +- Nach dem Umzugsauftrag `python3 deploy/dev.py down` tatsächlich ausgeführt: + eigene lokalen Server-/Datenbankcontainer gestoppt und entfernt; Datenvolume, + CA und Schlüssel erhalten. Keine fremden Container verändert. +- SSH-Hostschlüssel vom User bestätigt und strikt gepinnt. Vorhandener + Notebook-Schlüssel war bereits freigeschaltet; separater Schlüssel-Login + erfolgreich. Keine Notwendigkeit, das bereitgestellte Einmalpasswort zu + hinterlegen oder eine weitere Root-Schlüsseldatei zu verteilen. +- Inventur: Ubuntu **26.04**, **aarch64**, anfänglich nur SSH öffentlich. + Docker und Compose installiert, keine Distribution aktualisiert, kein Reboot. + Backend nativ auf dem ARM64-Server aus gepinnter Rust-Toolchain/Lockfile gebaut. + Das ist Backendbetrieb auf ARM64, keine ARM64-Agentfreigabe. +- Eigene Dienstidentität `rmm-server` mit UID 10001, Container unprivilegiert, + Root-Dateisystem readonly, Capabilities entfernt, NoNewPrivileges aktiv. + PostgreSQL gesund, Migrationen 1–12 auf frischem Bestand angewendet. +- SSH-Passwort-/Keyboard-Interactive-Anmeldung deaktiviert; Key-Login danach + erneut erfolgreich. Hostfirewall aktiv, eingehend nur TCP **22/443** erlaubt. + Keine fremden Dienste oder bestehenden Firewallregeln zurückgesetzt. +- `deploy/server.compose.yaml`: privater API-Dienst auf **127.0.0.1:18443**, + separater Gateway auf **127.0.0.1:18444**, PostgreSQL ohne publizierten Port. + Kein privater CA-Signierschlüssel im API-Container; Gateway hält die für + Enrollment erforderliche CA. Beide nutzen denselben dauerhaften DB-/Jobbestand. +- Host-Units `rmm-server-ingress.socket/service` nehmen öffentlich TLS auf 443 + an und leiten TCP zum Gateway weiter. Keine TLS-Terminierung im Proxy; + Clientzertifikate gelangen unverändert zum Rust-Gateway. +- Extern tatsächlich geprüft: `/healthz` **200**; `/`, `/auth/config`, + `/auth/dev/login`, `/mcp`, `/api/v1/tenants` jeweils **404**; öffentlicher + Signierschlüssel ohne Gerätezertifikat **401**. Fremde CA und falscher TLS-Name + werden verweigert. Ports **18443/18444/5432** extern nicht erreichbar. +- Eigene CA mit Server-SANs `discovery.ease-technologies.de`, `localhost` und + historischem Testalias `rmm-dev.internal`. Kein globaler Truststore verändert. + Neue Clients erhalten die öffentliche CA gezielt. Leaf-Zertifikat 30 Tage; + `rmm-server-tls-renew.timer` prüft täglich, erneuert bei weniger als sieben + Tagen Restlaufzeit und startet nur die eigenen API-/Gatewaycontainer neu. + Native Prüfung des aktuellen Nicht-Erneuerungsfalls bestanden. Erzwungene + Erneuerung und CA-Rotation wurden **nicht** abgenommen; vor CA-Ablauf ist + gesonderte kontrollierte Rotation nötig. +- Private WebUI über SSH-Tunnel unter **https://localhost:18443** erreichbar; + Originbindung und Anmeldung mit Secure-/HttpOnly-Cookie tatsächlich geprüft. + Simulierter dev/test-Principal, keine Produktions-/OIDC-Abnahme. + +## Tatsächliche Clientumstellung + +Die tatsächliche Linux-x86-64-Test-VM ist mit einer neuen getrennten Testidentität +direkt gegen den Server verbunden. Vor der Userkorrektur wurde zusätzlich ein +Notebook-Client angelegt und getestet; dieser ist inzwischen **gestoppt, +deinstalliert und seine Identität über die WebUI widerrufen**. Historisch wurden +für beide serverseitig frische Heartbeats, passives Inventar, mTLS-WSS, +Signierschlüsselbezug über den mTLS-Gateway und erfolgreicher signierter +Journalabgleich (`sync_ready=true`, `restore_blocked=false`) nachgewiesen. +Im Bestand bleibt der widerrufene Notebook-Datensatz als Historie; ausschließlich +die Cloud-VM darf als aktiver Client verbleiben. Tenant B sieht keines. **0 Jobs, 0 Outbox, +0 Startgrants** im neuen Serverbestand; keine UI-Freigabe oder Paketwirkung. + +- VM: neue Unit `rmm-agent-remote.service` aktiviert und aktiv, Netzwerkprozess + weiterhin unprivilegiert als `rmm-agent`. Neuer Zustand + `/var/lib/rmm-agent-remote`, Konfiguration `/etc/rmm-remote`, separates Binary. + Die alten Units bleiben inactive, alte Geräteidentität/Journale bleiben unter + ihren bisherigen Pfaden erhalten: historisch ein Hello-World-Erfolg, + Rootledger weiterhin 0 Verbräuche. Kein Reverse-Listener auf der VM. +- Notebook: Userdienst `rmm-agent-remote.service` gestoppt und deaktiviert, + Unit und installiertes Binary entfernt, Usermanager neu geladen. Livezustand + `~/.local/share/rust-discovery/remote-agent` entfernt. Private Journalhistorie + ohne installiertes Binary unter `devstate/uninstalled-local-client/` archiviert; + keine erneute Inbetriebnahme. Widerruf mit tatsächlichen UI-Interaktionen im + gekennzeichneten dev/test-Profil, Bestätigungskennung und explizitem Klick + erfolgt. Kein API-/DB-Widerruf als Umgehung der interaktiven Verwaltungsgrenze. +- Beim ersten VM-Bootstrap verhinderte die restriktive Umask die Ausführung + des neuen Binaries (systemd Exit 203). Nur die eigenen, per SHA geprüften + neuen Dateimodi korrigiert; denselben erhaltenen Bootstrap fortgesetzt. + Keine Identität gelöscht, kein Journalreset oder erneutes Enrollment. + Regression für Dateimodi, Verweigerung vorhandener Identitäten und Ablehnung + der entfernten Notebook-Installationsoption: 3 Tests grün. + +Clientvertrag für weitere Installationen: + +```ini +RMM_SERVER_NAME=discovery.ease-technologies.de +RMM_CONNECT_ADDR=88.99.80.202:443 +RMM_CA_FILE=/geschuetzter/pfad/server-ca.pem +``` + +`RMM_SERVER_NAME` wird für URL, SNI und Zertifikatsprüfung verwendet; +`RMM_CONNECT_ADDR` bleibt ausschließlich TCP-Ziel. Gleiches Namensprofil für +Enrollment, WSS, HTTPS, Signierschlüssel und Zertifikatserneuerung. Falscher Name, +fremde CA, URL-/Port-/Benutzerinjektion im Servernamen werden verweigert. +Rezept für Systemdienste: `deploy/linux/rmm-agent-remote.service`. +Bestehende lokale Entwicklungsdefaults sind keine neue Serverempfehlung. + +Weitere Clients erhalten nur öffentliche CA, eigenes kurzlebiges Einmaltoken +und ihre fest provisionierte öffentliche Geräte-/Tenant-/Signierbindung. +Private Geräteschlüssel erzeugt der Client selbst. **Kein Server-SSH-Key, +zentrales CA-Geheimnis oder globaler Bearer gehört auf zusätzliche Clients.** +`deploy/remote_client_bootstrap.py` ist ein administratives Werkzeug des +Entwicklernotebooks, kein an Kunden zu verteilender Installer. +Es bietet ausschließlich den create-only-Modus `--provision-vm`; `--resume-vm` setzt nur +den passenden eigenen, erhaltenen Bootstrap mit gleicher CA/Binärbindung fort. +Die lokale Installationsfunktion und `--provision-local` wurden entfernt. + +## Verwaltung und private Nachweise + +Ein Loopback-Tunnel vom Notebook läuft bereits. Manuelle Wiederherstellung +des Verwaltungszugangs, **nur bei freiem lokalem Port und ohne zweiten Tunnel**: + +```sh +ssh -N -T -o StrictHostKeyChecking=yes -o ExitOnForwardFailure=yes \ + -o ServerAliveInterval=30 -o ServerAliveCountMax=3 \ + -i ~/.ssh/ease_key.pem \ + -L 127.0.0.1:18443:127.0.0.1:18443 root@discovery.ease-technologies.de +``` + +Danach `https://localhost:18443`, mit explizitem Vertrauen in die Projekt-CA. +Nicht die Zertifikatsprüfung wegklicken/abschalten. Öffentliche CA lokal: +`credentials/server-ca.pem`; privater dev/test-Login: +`credentials/server-browser-login.json` (0600). Keine Inhalte veröffentlichen. +Tunnelreferenz `devstate/server-admin-tunnel.json`; Clientnachweise +`devstate/remote-vm.json`; Notebook-Deinstallations-/Widerrufsnachweis in +`devstate/remote-local.json` und `devstate/notebook-removal-ui.json`. +Der Verwaltungs-SSH-Tunnel ist ein Entwicklungswerkzeug, kein RMM-Agent. + +Serverinstallation `/opt/rust-discovery`; private Konfiguration, PKI und +Browserzugang dort unter `devstate/` (0700/0600). Datenbank in eigenem +Docker-Volume. Rohe Source-/Artefaktlogs unter `/var/log/rmm-server-*.log`, +sanitisiertes Prüfergebnis `/opt/rust-discovery/deployment-verification.json`. +Buildgebundene Quellen mit Notebook-Checkout abgeglichen: +`d50c5e82746f9675d50a24c385a0ad74cb666ed546d8dc7c732153cf7a862c9e`. + +## Offene MVP-Gates + +### Neuer tatsächlicher Cloud-Abnahmelauf (2026-11-13) + +Server weiterhin ausschließlich `discovery.ease-technologies.de`, Client +ausschließlich die bestehende Cloud-VM; kein Notebook-Client gestartet/enrolled. +`deploy/cloud_mvp_acceptance.py` verwendet einen echten Streamable-HTTP-MCP-Client +mit initialisierter Sitzung. Der öffentliche Agentzugang bleibt unverändert; +MCP und WebUI laufen privat auf dem Server bzw. durch den Verwaltungs-SSH-Tunnel. +MCP-Bearer bleiben auf dem Server. Genehmigung ausschließlich über sichtbare +WebUI-Interaktionen mit dem gekennzeichneten simulierten Testprincipal. + +Tatsächlich nachgewiesen, jeweils ein neuer fester, separat UI-genehmigter Plan: + +| Fall | Ergebnis | Job / Outbox / Startgrant | +| --- | --- | --- | +| Hello World über WSS | Exit 0, exakte Ausgabe und Nachbedingung bestätigt | 1 / 1 / 1 | +| Hello World über HTTPS-Long-Polling | Exit 0, exakte Ausgabe und Nachbedingung bestätigt | 1 / 1 / 1 | +| Angeforderte Live-Inventur über HTTPS | Neuer Erhebungszeitpunkt nach gebundenem Planbeginn, Nachbedingung bestätigt | 1 / 1 / 1 | +| Genehmigter Hello-Auftrag mit künftigem Start, danach MCP-Abbruch | `cancelled`, kein Startgrant | 1 / 1 / 0 | + +Vor jeder Genehmigung `pending_approval`, keine Ausführung, für den festen Job +**0/0/0** gemessen. Alle vier Audits binden Principal, Planhash, +`approval_origin=dev_test_browser_simulation` und `testsimulation=true`. +Snapshot nach der Basisstrecke: **3 succeeded, 1 cancelled; 4 Jobs / 4 Outbox / 3 Grants**, +keine ungeklärten oder laufenden Jobs. Die weiter oben genannten 0/0/0-Werte +sind der historische Umzugssnapshot, kein aktueller Gesamtzähler. + +- MCP von Mandant B auf Gerät und Job von A verweigert. Wiederholtes Submit + derselben Pläne/Idempotenzschlüssel liefert dieselben Operationen, keine neue + Ausführung. Kein MCP-Genehmigungswerkzeug oder API-/DB-Genehmigungsaufruf. +- Gateway tatsächlich neu gestartet. HTTPS-Sitzung blieb mit erneuter Prüfung + pro HTTP-Anfrage gültig. Ein anfänglicher Test verlangte dafür fälschlich eine + höhere Verbindungsgeneration und lief in sein 100-Sekunden-Limit; daraus wird + kein Reconnect-Erfolg behauptet. Danach echter WSS-Reconnect separat geprüft: + höhere Generation, frischer Heartbeat, signierter Sync, unveränderte 4/4/3. + Cloud-VM wieder auf WSS; Identität und Journale unverändert erhalten. +- Die neue Auswertung musste leere SSE-Initialframes und Rust-RFC3339-Zeiten mit + Nanosekunden auf Python 3.10 berücksichtigen. Live-Inventur war schon erfolgreich; + ihr vorhandenes Ergebnis wurde nach Parserkorrektur rein lesend verifiziert. + Kein Wiederholen des Jobs, um die Auswertung grün zu machen. +- Lokale Prüfungen: **5 Cloud-Guards**, **28 bestehende MVP-Guards**, + **3 Bootstrap-Guards** bestanden; neue Browserdatei per Node-Syntaxprüfung. + Browservertrauen separat im privaten NSS-Profil unter + `web/node_modules/.cache/cloud-acceptance/home`, keine globale CA-Änderung. + +Tatsächlich ausgeführte Abnahmebefehle: + +```sh +python3 deploy/cloud_mvp_acceptance.py --execute-dev-test-ui --case hello +python3 deploy/cloud_mvp_acceptance.py --execute-dev-test-ui --case hello --transport https +python3 deploy/cloud_mvp_acceptance.py --execute-dev-test-ui --case refresh_inventory +python3 deploy/cloud_mvp_acceptance.py --execute-dev-test-ui --case cancel_queued +``` + +Nicht blind erneut ausführen: diese Befehle erstellen neue genehmigungspflichtige +Pläne. Geschützte Einzelbelege und Checkpoints unter +`devstate/cloud-acceptance//checkpoint.json`, Wiederanlaufbeleg unter +`devstate/cloud-acceptance/reconnect.json`. Unklarer Ausgang bleibt ungeklärt; +keine automatische neue Wirkung oder neue Genehmigung als vermeintliche Redelivery. + +Der Serverumzug ist ausgeführt; das Linux-MVP ist weiterhin **nicht vollständig +abgenommen**. Die oben nachgewiesenen UI-genehmigten Basisfälle sind keine Root-/ +Paketabnahme. Produktions-OIDC und öffentliche Verwaltung sind nicht eingerichtet. +Native Rotations-/Recovery-/Replay-/Offline-Ablauf-Abnahmen bleiben gesonderte +Arbeitspakete. Der nachfolgende Root-/APT-Abschnitt aktualisiert deren Stand. + +## Root-/APT-Abnahmelauf 2026-11-13 + +Die Cloud-VM behält ihre bestehende Gerätebindung. Versionierte Bootstrap- +Werkzeuge `deploy/cloud_root_bootstrap.py` und `cloud_root_clock_upgrade.py` +erhalten beide Agentzustände/Journale, den bisherigen Rootledger-Inode sowie +Archive, Baselines, Vorprüfungen und sämtliche Fehlernachweise. Kein erneutes +Enrollment oder Ledgerreset. Rootdateien unter `/var/lib/rmm-bootstrap-history/` +werden exklusiv mit 0700/0600 aufbewahrt; Teilinstallationen werden nicht blind +erneut ausgeführt. + +Erster Readonly-APT-Probe auf der echten VM erfolgreich; anschließende Daemons +jedoch nicht stabil: glibc-Zeitabfrage über Syscall `clock_adjtime` wurde vom +Unitfilter blockiert (allgemeiner Helper SIGSYS, APT `CLOCK_UNTRUSTED`). Der alte +Bootstrap meldete nach Type=simple-Spawn verfrüht Erfolg; dieser Eintrag gilt +ausdrücklich nicht als stabile Bereitschaft. Enger Filterfix erlaubt zusätzlich +`clock_adjtime`, ohne CAP_SYS_TIME und ohne Änderung der vertrauenswürdigen +Zeitprüfung. Nach versioniertem Artefakt-/Profilwechsel tatsächlichen Probe +erneuert, beide Daemons zehnmal laufend/ohne Restart geprüft, gemeinsames Ledger +einmal an die bestehende Cloudidentität gebunden. Ein anfängliches `reset-failed` +auf nach Reload ungeladenen, inaktiven Units schlug fehl; Fortsetzung ausschließlich +des installierten Startschritts, ohne Paketjob oder Zustandslöschung. Bootstrap +wartet inzwischen auf stabilen Betrieb statt nur den Spawn zu bestätigen. + +Installiertes Clock-Fix-Helperartefakt: +`dba16402af1e8b8655ec69495cf370d019bc32b9f05e61be4147df29cd7bf176`. +Gemessene Runtime: +`0547c9886aae77775c373c81758166ad41aced236d428fdf299d8e7784751d10`. +Allgemeiner Policypin: +`e177ab083ba0c239103942eb67ea9e28e9dafc294f828592cf859535a8569fd8`; +APT-Stackpin: +`0b71b79a2f59c5019472e7366ede9f155850749afec7ec29ccff91f3226be56b`. +Pins über Rootinstallation und tatsächliche nonce-/Root-Peer-gebundene +Controlantworten als `rmm-agent` geprüft. Beide Helper teilen die exakt gleichen +Ledger-/Lock-Inodes. Vor erstem Rootjob 0 Verbrauchseinträge, 0 Syncfehler. +Dies ist Readiness, keine vorweggenommene Paket-Acceptance. + +`deploy/cloud_root_policy.py` installierte eine zweistündig befristete Policy +für genau diese Gerätegeneration/-zuordnung, beide gemessenen Helperpins und +ausschließlich `simulated-testprincipal-a`. Allgemein nur Rootskript und +`rmm-mvp-test.service`; APT nur die eingebauten Fixturemanifeste und exakten +Provider-/Hook-/Config-/Runtimehashes. Kein Reboot, keine MCP-Rechteerweiterung. +Compose bindet das private Policyverzeichnis readonly; Dateimodus 0600, +Eigentümer 10001, Verzeichnis 0700. Default ohne ausdrückliche Konfiguration: +`RMM_DEV_ROOT_ENABLED=false`. Policies begrenzen nur, sie genehmigen keine Jobs. + +`deploy/cloud_root_acceptance.py` verwendet zwei getrennte tatsächliche +WebUI-Sitzungen: Rootplan erstellen/beantragen, dann unveränderliche Bytes/ +Hashes/Ziele/Versuche prüfen und genehmigen. Dazwischen MCP-lesender Abgleich +und SQL-Nachweis 0 Jobs/Outbox/Startgrants. Bestehende Browserverträge werden mit +`deploy/browser/cloud-root.config.ts` über den privaten Cloud-SSH-Tunnel genutzt; +kein lokaler Server oder Client. Ein fehlerhafter exakter Interpreter-Labelselector +stoppte zuerst vor der Planung; auf die tatsächliche Combobox umgestellt. Nur +die Formularvorbereitung fortgesetzt, kein ausgeführter Job wiederholt. + +| Fall | Reales Ergebnis | Vorher → nach Genehmigung | +| --- | --- | --- | +| `service_setup` | Rootskript, exakte Ausgabe, `succeeded` | 0/0/0 → 1/1/1 | +| `service_start` | Dienst läuft, `succeeded` | 0/0/0 → 1/1/1 | +| `service_stop` | Dienst gestoppt, `succeeded` | 0/0/0 → 1/1/1 | +| `apt_native_install` | `failed / HOOK_NOT_HANDED_OFF`, keine Acceptance | 0/0/0 → 1/1/1 | + +Alle vier Authorizations rein lesend mit festem Planhash, sichtbarem Testprincipal, +`approval_origin=dev_test_browser_simulation`, `testsimulation=true` verifiziert. +Keine direkte API-/DB-Genehmigung. Kein Produktions-Freigabenachweis. + +Beim APT-Versuch sind `native-prechecks.json`, `sandbox-ready.json` und +`sandbox-result.json` tatsächlich vorhanden: private Namespaces, genaue +Cap-/NNP-/Seccomp-Sätze, readonly Controlmounts, ungültige Kontrollsyscalls EPERM +und echter Frontend-Lockkonflikt bestanden. Anschließend **APT Exit 100**, +kein `hook-armed.json`, keine native Acceptance. Elternprozess prüfte gesamten +Paketbaselinezustand unverändert; frisches passives gespeichertes Inventar +bestätigte unveränderte Baseline/Statusfingerprint, Fixture nicht installiert. +APT-stdout/stderr wurden bisher verworfen; konkrete Ursache von Exit 100 ist +offen. `--no-download`, Archive oder Hook dürfen nicht auf Verdacht gelockert +werden. Kein manuelles apt/dpkg auf dem Ziel, kein neuer Versuch/Rezeptalias. + +Der Rootledger enthält danach **4 abgeschlossene Verbrauchseinträge**, keine +unbekannte/offene Wirkung und keinen sticky Syncfehler; Integrität ok. Der +Create-once-Marker und `active/` bleiben unverändert. Install 1.0, Upgrade 1.1, +EnsurePackage und ApplyUpdates sind **nicht abgenommen**. Vor einer Fortsetzung +braucht es eine auditierbare, sichere Behandlung dieses erhaltenen Fehlversuchs; +Marker löschen, Ledgerreset, neue Identität oder eine alternative Rezeptkennung +als Wiederholungsabkürzung sind ausgeschlossen. Ein neuer ausführbarer Versuch +benötigt einen neuen festen, tatsächlich WebUI-genehmigten Plan. + +Codeprüfung nach dem Fehlversuch fand zusätzlich einen Cloudlayout-Fehler: die +bisherige Worker-Maskierung umfasste `/etc/rmm` und `/var/lib/rmm-agent`, aber noch +nicht `/etc/rmm-remote` und `/var/lib/rmm-agent-remote`. Quellcode korrigiert: +beide Layouts maskieren, sichtbare Inhalte oder Symlinks unabhängig vom konkreten +Schlüsseldateinamen verweigern. **58 Python-APT-Tests bestanden; dieser Fix ist +noch nicht auf der VM installiert oder nativ abgenommen.** Er verändert +Provider-/Helper-/Runtimehashes. Bisherige Readiness ist keine Abnahme dieses +neuen Codes; keine erneute create-only Installation über verbrauchten Zustand. + +Abschließend Rootpolicy explizit geschlossen (serverseitig abgelaufen), bisherige +Policy gesichert. APT-Helper gestoppt/deaktiviert und ausschließlich seine +eigenen Socket-/Proof-Variablen aus dem gesicherten Agentdrop-in entfernt +(`deploy/cloud_root_pause_apt.py`). Ledger-Inode und Versuchsmarkerhash dabei +unverändert. Cloud-Agent/allgemeiner Helper bleiben aktiv. Testdienst inactive. +Abschlussmessung: Agent `online`, signierter Sync `ready`, kein Restoreblock, +keine APT-Capabilities; APT-Daemon inactive/disabled; Policy tatsächlich abgelaufen, +weiterhin UID10001/0600. Beleg `devstate/cloud-root/closed-state-*.json`. +Notebook-Clientunit weiterhin `not-found/inactive`, keine laufenden RMM-Container +auf dem Notebook. Andere lokale Projekte wurden nicht verändert. Öffentliche +Routen `/`, `/auth/config`, `/mcp` nach Serverkonfigurationsänderung weiterhin 404 +über verifiziertes TLS. + +Gesamtsnapshot: **6 succeeded / 1 failed / 1 cancelled; 8 Jobs / 8 Outbox / +7 Startgrants; 0 ungeklärte/laufende Jobs**. Private Evidenz: +`devstate/cloud-root/{install-*,clock-*,health-*,peer-readiness-before-apt.json, +cases/*/checkpoint.json,apt-failure-*,final-*,policy-*,apt-paused-*}` und +Root-Backups auf der VM/im Server. Nichts davon committen oder veröffentlichen. + +Tatsächlich ausgeführt (keine Anleitung zum blinden Wiederholen): + +```sh +python3 deploy/cloud_root_bootstrap.py --install-reviewed-helper +python3 deploy/cloud_root_acceptance.py --case service_setup +python3 deploy/cloud_root_acceptance.py --case service_setup --resume-prepared +python3 deploy/cloud_root_acceptance.py --case service_start +python3 deploy/cloud_root_acceptance.py --case service_stop +python3 deploy/cloud_root_acceptance.py --case apt_native_install +python3 deploy/cloud_root_policy.py --close-reviewed-test-scope +python3 deploy/cloud_root_pause_apt.py +``` + +Clockupgrade und ausschließlich dessen installierter Startschritt wurden ebenfalls +ausgeführt; Zwischenfehler bleiben in geschützten Reports erhalten. Lokale Suites: +58 Python-APT / 8 Cloud-Guards / 28 MVP-Guards / 3 Bootstrap-Guards bestanden. +Helper nach Clockprofil und separat nach Cloud-Controlpfad-Fix: jeweils +25 Library / 3 Binary / 20 Sync bestanden. Keine +vollständige Frontend-/MVP-/APT-Abnahme aus lokalen Tests ableiten. + +## Nächste Schritte (geplant, nicht ausgeführt) + +1. Die weiteren Fehler-/Offline-/Replayfälle der WebUI/MCP-/Jobstrecke auf dem + neuen Server abnehmen; ausschließlich feste UI-genehmigte Pläne. +2. APT-100-Ursache durch begrenzte sichere Diagnose bestimmen; Cloudlayout- + Maskierungsfix kontrolliert mit erhaltenem Ledger/Marker installieren und + native Readiness erneuern. Sichere Behandlung des gespeicherten Fehlversuchs + vor weiterem Paketjob klären/implementieren; keine Guard- oder Genehmigungsabkürzung. +3. Gesonderte Daten-/Schlüsselbackup- und Restoreabnahme sowie CA-Rotation + vorbereiten. Zertifikatswartung ersetzt kein Backup oder Produktionsnachweis. diff --git a/tests/apt_transaction/test_guard.py b/tests/apt_transaction/test_guard.py index a5e365e..71951a8 100644 --- a/tests/apt_transaction/test_guard.py +++ b/tests/apt_transaction/test_guard.py @@ -212,6 +212,29 @@ class PreconditionsTests(unittest.TestCase): with self.assertRaises(apt.Veto): apt.inspect_sandbox() + def test_private_control_layouts_must_be_empty_or_absent_in_worker(self): + for layout in ('etc-rmm', 'etc-rmm-remote', 'rmm-helper', 'rmm-agent', 'rmm-agent-remote'): + with self.subTest(layout=layout), tempfile.TemporaryDirectory() as temp: + path = Path(temp) / layout + with patch.object(apt, 'PRIVATE_CONTROL_DIRECTORIES', (str(path),)): + apt.inspect_private_control_paths() # optional layout absent + path.mkdir() + apt.inspect_private_control_paths() # masked empty directory + (path / 'arbitrary-future-secret-name').write_text('synthetic') + with self.assertRaisesRegex(apt.Veto, 'SANDBOX_LEDGER_OR_KEYS_VISIBLE'): + apt.inspect_private_control_paths() + + def test_private_control_symlink_cannot_claim_an_empty_mask(self): + with tempfile.TemporaryDirectory() as temp: + base = Path(temp); (base / 'empty').mkdir() + (base / 'link').symlink_to(base / 'empty', target_is_directory=True) + with patch.object(apt, 'PRIVATE_CONTROL_DIRECTORIES', (str(base / 'link'),)): + with self.assertRaisesRegex(apt.Veto, 'SANDBOX_LEDGER_OR_KEYS_VISIBLE'): + apt.inspect_private_control_paths() + (base / 'empty').rmdir() # dangling symlink is not an absent layout + with self.assertRaisesRegex(apt.Veto, 'SANDBOX_LEDGER_OR_KEYS_VISIBLE'): + apt.inspect_private_control_paths() + def test_previous_launch_or_handoff_is_unknown_never_relaunched(self): for marker in ('launch.json', 'hook-armed.json'): with tempfile.TemporaryDirectory(dir='/tmp/opencode') as temp: diff --git a/tests/apt_transaction/test_readiness_probe.py b/tests/apt_transaction/test_readiness_probe.py index eccf9df..82d8a86 100644 --- a/tests/apt_transaction/test_readiness_probe.py +++ b/tests/apt_transaction/test_readiness_probe.py @@ -170,6 +170,13 @@ print('CLONE_GAPS_CLOSED') def test_dedicated_unit_has_narrow_profile_without_weakening_general_unit(self): unit = (ROOT / 'deploy/linux/rmm-apt-helper.service').read_text() + # Explicit User=root triggers systemd 255's seccomp/setuid path: + # CAP_SETUID disappears from E/P and setup capabilities leak into I. + # Default root preserves the exact controller profile, not extra caps. + self.assertFalse(any(line.startswith('User=') for line in unit.splitlines())) + self.assertIn('Group=rmm-agent', unit) + self.assertIn('SystemCallFilter=adjtimex clock_adjtime', unit) + self.assertNotIn('CAP_SYS_TIME', next(line for line in unit.splitlines() if line.startswith('CapabilityBoundingSet='))) for required in ('NoNewPrivileges=true', 'PrivateNetwork=true', 'ProtectSystem=strict', 'RestrictNamespaces=mnt pid net', 'DevicePolicy=strict', 'PrivateDevices=no', 'AmbientCapabilities=', 'SystemCallArchitectures=native'): diff --git a/tests/browser/mvp-actions.spec.ts b/tests/browser/mvp-actions.spec.ts index cb3af14..a769c65 100644 --- a/tests/browser/mvp-actions.spec.ts +++ b/tests/browser/mvp-actions.spec.ts @@ -41,7 +41,7 @@ test('simulated human prepares root request through UI only, without approving', const variants = params.variants; if (!Array.isArray(variants) || variants.length !== 1) throw new Error('One exact script variant required'); const variant = object(variants[0]); - await page.getByLabel('Interpreter', { exact: true }).selectOption(text(variant.interpreter)); + await page.getByRole('combobox', { name: 'Interpreter', exact: true }).selectOption(text(variant.interpreter)); await page.getByLabel('Exakte UTF-8 Skriptbytes', { exact: false }).fill(text(variant.script_utf8)); await page.getByLabel('Erwartete stdout-Ausgabe', { exact: false }).fill(text(params.expected_stdout)); } else { @@ -130,7 +130,7 @@ test('one opted-in immutable dev/test action: inspect all fixed bytes → UI cli expect(payload.execution_identity).toBe('root'); expect(action.action).toBe('run_script'); expect(action.interpreter).toBe('posix_sh'); expect(action.arguments).toEqual([]); expect(action.expected_stdout).toBe('RMM test unit prepared\n'); - expect(createHash('sha256').update(text(action.script_utf8)).digest('hex')).toBe('159ff240504b8a350b46a56fdf9cd50e5768816de7e6683829f05144978449f0'); + expect(createHash('sha256').update(text(action.script_utf8)).digest('hex')).toBe('3e299e84021beaa4cbdce6fa63eda193f6f123aba86368890fe20684c43e78ae'); expect(payload.max_runtime_seconds).toBe(60); } else if (expected.case === 'refresh_inventory') { expect(payload.execution_identity).toBe('agent_service'); diff --git a/tests/browser/safe-reporter.ts b/tests/browser/safe-reporter.ts index 0348ce5..b66bcdd 100644 --- a/tests/browser/safe-reporter.ts +++ b/tests/browser/safe-reporter.ts @@ -6,7 +6,16 @@ import { diagnostic } from './diagnostics'; export default class SafeReporter implements Reporter { private executed = 0; onBegin() { console.log('Dev/test browser simulation suite. Secret-bearing step/error logs suppressed.'); } - onTestEnd(_test: TestCase, result: TestResult) { if (result.status !== 'skipped') this.executed++; console.log(`Browser simulation: ${result.status}.`); } + onTestEnd(_test: TestCase, result: TestResult) { + if (result.status !== 'skipped') this.executed++; + console.log(`Browser simulation: ${result.status}.`); + // Extract only repository source line numbers. Assertion text, call logs + // and entered form values (including passwords) remain suppressed. + for (const error of result.errors) { + const match = error.stack?.match(/mvp-actions\.spec\.ts:(\d+):\d+/); + if (match) console.log(`Cloud/root UI failure source_line=${Number(match[1])}`); + } + } onStepEnd(_test: TestCase, _result: TestResult, step: TestStep) { if (step.category !== 'test.step') return; const safe = diagnostic(step.title, step.error, step.location?.line); diff --git a/tests/cloud_mvp_guards.py b/tests/cloud_mvp_guards.py new file mode 100644 index 0000000..832dd81 --- /dev/null +++ b/tests/cloud_mvp_guards.py @@ -0,0 +1,92 @@ +"""Cloud acceptance regressions: no network, client, approval or database.""" +import io +import json +from pathlib import Path +import sys +import unittest +from unittest.mock import patch + +sys.path.insert(0,str(Path(__file__).resolve().parents[1]/'deploy')) +import cloud_mvp_acceptance as cloud +import cloud_root_acceptance as root_acceptance + + +class CloudGuards(unittest.TestCase): + def test_native_chrono_nanoseconds_are_read_without_repeating_the_job(self): + value='2026-11-13T10:21:39.987858213Z' + self.assertEqual(cloud.contract.timestamp(value),cloud.contract.timestamp('2026-11-13T10:21:39.987858Z')) + self.assertEqual(value,'2026-11-13T10:21:39.987858213Z') + for fraction in ('1','12','123','1234','12345','123456','123456789'): + self.assertEqual(cloud.contract.timestamp('2026-11-13T10:21:39.'+fraction+'Z').microsecond, + int((fraction+'000000')[:6])) + with self.assertRaises(cloud.contract.GuardError):cloud.contract.timestamp('2026-11-13T10:21:39.987858') + + def test_sse_empty_initial_data_is_not_a_json_response(self): + class Response: + status=200 + def __init__(self):self.stream=io.BytesIO(b'event: message\ndata: \n\nevent: message\ndata: {"jsonrpc":"2.0","id":1,"result":{"ok":true}}\n\n') + def getheaders(self):return [('Content-Type','text/event-stream')] + def getheader(self,key,default=''):return 'text/event-stream' + def readline(self,size):return self.stream.readline(size) + class Connection: + def __init__(self,*args,**kwargs):pass + def request(self,*args,**kwargs):pass + def getresponse(self):return Response() + def close(self):pass + with patch.object(cloud.http.client,'HTTPSConnection',Connection), \ + patch.object(cloud.ssl,'create_default_context'), \ + patch.object(Path,'read_text',return_value='synthetic-test-bearer'): + response=cloud.server(dict(kind='http',path='/mcp',method='POST',body={},headers={})) + self.assertTrue(response['data']['result']['ok']) + + def test_cloud_adapter_cannot_target_an_approval_or_enrollment_endpoint(self): + for path in ('/agent/v1/enroll','/api/v1/tenants/t/operation-plans/p/authorizations','/auth/dev/login'): + with self.subTest(path=path),self.assertRaisesRegex(RuntimeError,'no administrative mutation endpoint'): + cloud.server(dict(kind='http',path=path)) + + def test_caller_cannot_inject_interactive_or_bearer_credentials(self): + for key in ('Cookie','authorization','X-CSRF-Token'): + with patch.object(cloud.ssl,'create_default_context'),self.subTest(key=key), \ + self.assertRaisesRegex(RuntimeError,'caller credential injection'): + cloud.server(dict(kind='http',path='/mcp',headers={key:'synthetic'},body={},method='POST')) + + def test_browser_authorization_uses_only_the_actual_ui(self): + code=(cloud.ROOT/'deploy/browser/cloud_approve.cjs').read_text() + self.assertNotIn('page.request.',code) + self.assertNotIn('page.evaluate(',code) + self.assertNotIn(".post('/",code) + self.assertIn('await approve.click()',code) + self.assertIn('ignoreHTTPSErrors: false',code) + + def test_cloud_root_runner_refuses_reboot_before_starting_a_browser(self): + value=dict(profile='dev/test',case='reboot_last',expected_principal='simulated-testprincipal-a') + with patch.object(cloud.contract,'protected_json',return_value=value), \ + patch.object(cloud,'prepare_browser') as trust, \ + patch.object(root_acceptance.browser.subprocess,'run') as run: + with self.assertRaisesRegex(RuntimeError,'fixed cloud root cases only'): + root_acceptance.browser.run('/synthetic/case.json') + trust.assert_not_called();run.assert_not_called() + + def test_root_preparation_requires_explicit_root_identity(self): + value=dict(profile='dev/test',case='service_start',phase='prepare',expected_principal='simulated-testprincipal-a', + request=dict(parameters=dict(execution_identity='agent_service'))) + with patch.object(cloud.contract,'protected_json',return_value=value), \ + patch.object(cloud,'prepare_browser') as trust: + with self.assertRaisesRegex(RuntimeError,'root preparation only'): + root_acceptance.browser.run('/synthetic/case.json',prepare=True) + trust.assert_not_called() + + def test_unresolved_cloud_effect_blocks_every_new_root_request(self): + identity=dict(agent_id='synthetic-agent',asset_id='synthetic-asset') + with patch.object(sys,'argv',['cloud_root_acceptance.py','--case','apt_native_install']), \ + patch.object(Path,'exists',return_value=False), \ + patch.object(cloud.contract,'protected_json',return_value=dict(identity=identity)), \ + patch.object(cloud,'Backend') as backend, \ + patch.object(cloud.bootstrap,'rpc',return_value=dict(unresolved=1)), \ + patch.object(root_acceptance.browser,'run') as browser: + with self.assertRaisesRegex(cloud.contract.GuardError,'unresolved central job'): + root_acceptance.main() + backend.return_value.call.assert_not_called();browser.assert_not_called() + + +if __name__=='__main__':unittest.main() diff --git a/tests/test_remote_client_bootstrap.py b/tests/test_remote_client_bootstrap.py new file mode 100644 index 0000000..6a758cf --- /dev/null +++ b/tests/test_remote_client_bootstrap.py @@ -0,0 +1,73 @@ +"""Bootstrap guard regressions; no SSH, system service or actual chown.""" +import base64 +import hashlib +from pathlib import Path +import os +import subprocess +import sys +import tempfile +from types import SimpleNamespace +import unittest +from unittest.mock import patch + +sys.path.insert(0, str(Path(__file__).resolve().parents[1]/'deploy')) +import remote_client_bootstrap as bootstrap + + +class InstallationGuards(unittest.TestCase): + def staged_install(self, existing=False): + with tempfile.TemporaryDirectory() as folder: + root = Path(folder) + def mapped(path): + return root/str(path).lstrip('/') + for name in ('usr/local/libexec', 'etc/systemd/system', 'var/lib'): + (root/name).mkdir(parents=True, exist_ok=True) + state = root/'var/lib/rmm-agent-remote' + if existing: + state.mkdir(mode=0o700) + (state/'identity.json').write_bytes(b'preserved identity') + binary = b'\x7fELF\x02\x01'+b'\x00'*12+b'\x3e\x00'+b'\x00'*64 + payload = dict(action='install', binary=base64.b64encode(binary).decode(), + binary_sha256=hashlib.sha256(binary).hexdigest(), token='x'*64, + ca=base64.b64encode(b'public CA').decode(), unit='reviewed fixture unit', + environment='reviewed fixture environment') + original = os.umask(0o077) + try: + with patch.object(bootstrap, 'Path', side_effect=mapped), \ + patch.object(bootstrap.os, 'geteuid', return_value=0), \ + patch('pwd.getpwnam', return_value=SimpleNamespace(pw_uid=993, pw_gid=984)), \ + patch.object(bootstrap.os, 'chown'), \ + patch.object(bootstrap.subprocess, 'run', return_value=SimpleNamespace(stdout=b'inactive\n')) as run: + if existing: + with self.assertRaisesRegex(RuntimeError, 'existing installation'): + bootstrap.vm(payload) + self.assertEqual((state/'identity.json').read_bytes(), b'preserved identity') + self.assertFalse((root/'usr/local/libexec/rmm-agent-remote').exists()) + return + result = bootstrap.vm(payload) + self.assertTrue(result['installed']) + self.assertEqual((root/'usr/local/libexec/rmm-agent-remote').stat().st_mode & 0o777, 0o755) + self.assertEqual((root/'etc/rmm-remote').stat().st_mode & 0o777, 0o755) + self.assertEqual((root/'etc/rmm-remote/ca.pem').stat().st_mode & 0o777, 0o644) + self.assertEqual((root/'etc/rmm-remote/agent.env').stat().st_mode & 0o777, 0o600) + self.assertEqual((state/'enroll.token').stat().st_mode & 0o777, 0o600) + for call in run.call_args_list: + self.assertNotIn('start', call.args[0]) + finally: + os.umask(original) + + def test_private_umask_does_not_prevent_unprivileged_execution_or_public_ca_read(self): + self.staged_install() + + def test_existing_identity_is_preserved_and_never_reenrolled(self): + self.staged_install(existing=True) + + def test_notebook_installation_option_is_rejected_before_any_remote_action(self): + result = subprocess.run([sys.executable, str(Path(bootstrap.__file__)), '--provision-local'], + capture_output=True, timeout=10) + self.assertEqual(result.returncode, 2) + self.assertFalse(hasattr(bootstrap, 'local')) + + +if __name__ == '__main__': + unittest.main() diff --git a/tests/vm_mvp_guards.py b/tests/vm_mvp_guards.py index bc6634d..994cdd0 100644 --- a/tests/vm_mvp_guards.py +++ b/tests/vm_mvp_guards.py @@ -73,7 +73,13 @@ class Guards(unittest.TestCase): setup=m.case_input('service_setup',self.settings())['parameters'] self.assertEqual(setup['execution_identity'],'root') self.assertEqual(hashlib.sha256(setup['variants'][0]['script_utf8'].encode()).hexdigest(), - '159ff240504b8a350b46a56fdf9cd50e5768816de7e6683829f05144978449f0') + '3e299e84021beaa4cbdce6fa63eda193f6f123aba86368890fe20684c43e78ae') + # The browser independently pins the reviewed bytes at the UI boundary. + # Check that pin locally as well; do not wait for a live approval run to + # discover drift between the two acceptance paths. + browser=(m.ROOT/'tests/browser/mvp-actions.spec.ts').read_text() + self.assertIn("update(text(action.script_utf8)).digest('hex')).toBe('" + + hashlib.sha256(setup['variants'][0]['script_utf8'].encode()).hexdigest() + "')", browser) artifact=dict(self.artifact(),approved_cases=['service_setup','service_start','service_stop']) m.validate_run_artifact(artifact,self.settings(),['service_setup','service_start','service_stop']) with self.assertRaises(m.GuardError):m.validate_run_artifact(artifact,self.settings(),['service_start','service_setup','service_stop']) diff --git a/tools/apt-transaction/apt_transaction.py b/tools/apt-transaction/apt_transaction.py index dcbe065..ec8451f 100644 --- a/tools/apt-transaction/apt_transaction.py +++ b/tools/apt-transaction/apt_transaction.py @@ -29,6 +29,8 @@ ACTIVE = BASE / 'active' CODE = Path('/usr/lib/rmm-apt-transaction/apt_transaction.py') HOOK = '/usr/lib/rmm-apt-transaction/hook' APT_UNIT = Path('/etc/systemd/system/rmm-apt-helper.service') +PRIVATE_CONTROL_DIRECTORIES = ('/etc/rmm', '/etc/rmm-remote', '/var/lib/rmm-helper', + '/var/lib/rmm-agent', '/var/lib/rmm-agent-remote') MAX_INPUT = 1024 * 1024 MAX_PACKAGES = 128 RESOLVER = 'rmm-apt-local-v1' @@ -993,6 +995,7 @@ def inspect_sandbox(workspace=None): require(not Path('/var/lib/rmm-helper/consumption.sqlite').exists() and not Path('/etc/rmm/helper.json').exists() and not Path('/etc/rmm/apt-helper.json').exists(), 'SANDBOX_LEDGER_OR_KEYS_VISIBLE') + inspect_private_control_paths() # Parent gives us the original namespace identities; cannot accept flags alone. workspace = ACTIVE if workspace is None else workspace ids = json_bytes(sealed_read(workspace / 'host-namespaces.json')) @@ -1000,6 +1003,15 @@ def inspect_sandbox(workspace=None): require(os.readlink('/proc/self/ns/' + name) != ids[name], 'SANDBOX_NAMESPACE') +def inspect_private_control_paths(): + # Validate directory contents rather than guessing future key filenames. + # Both historical and current cloud identity/config layouts must be hidden. + for name in PRIVATE_CONTROL_DIRECTORIES: + path = Path(name) + require(not path.is_symlink() and (not path.exists() or (path.is_dir() + and next(path.iterdir(), None) is None)), 'SANDBOX_LEDGER_OR_KEYS_VISIBLE') + + def setup_sandbox(workspace=None, probe_db=None): """One trusted setup implementation for real jobs AND read-only probes.""" workspace = ACTIVE if workspace is None else workspace @@ -1018,9 +1030,9 @@ def setup_sandbox(workspace=None, probe_db=None): # available to the package child. Only the outside root controller sees them. for hidden in ('/etc/rmm', '/var/lib/rmm-helper'): require(Path(hidden).is_dir(), 'SANDBOX_PRIVATE_CONTROL_PATH_REQUIRED') - mount(['-t', 'tmpfs', '-o', 'mode=0700,nosuid,nodev,noexec', 'tmpfs', hidden]) - for hidden in ('/var/lib/rmm-agent', '/home', '/root'): + for hidden in (*PRIVATE_CONTROL_DIRECTORIES, '/home', '/root'): if Path(hidden).is_dir(): + require(not Path(hidden).is_symlink(), 'SANDBOX_PRIVATE_CONTROL_PATH_REQUIRED') mount(['-t', 'tmpfs', '-o', 'mode=0700,nosuid,nodev,noexec', 'tmpfs', hidden]) # Hide ALL conventional host control sockets, not merely systemctl binaries. mount(['-t', 'tmpfs', '-o', 'mode=0755,nosuid,nodev,noexec', 'tmpfs', '/run'])