From d38d93d2840807fdc3c79af836c9c5dfc2dc31a5 Mon Sep 17 00:00:00 2001 From: Kevin Janssen Date: Fri, 13 Nov 2026 16:18:04 +0100 Subject: [PATCH] feat: accept native Windows passive client and tenant-safe inventory migration --- README.md | 24 ++++--- .../agent-windows/examples/passive_state.rs | 27 ++++++++ crates/agent-windows/tests/native_acl.rs | 69 +++++++++++++++++++ deploy/cloud_server_upgrade.py | 35 +++++++++- deploy/windows/CLIENT.md | 68 +++++++++++++++--- deploy/windows/client_bootstrap.py | 58 +++++++++++----- docs/handover.md | 30 +++++--- docs/implementation-status.md | 44 ++++++++++++ docs/platform-support.md | 23 +++++++ docs/server-deployment.md | 9 +++ migrations/0013_windows_inventory_scope.sql | 6 ++ tests/windows_inventory_migration.py | 57 +++++++++++++++ tools/apt-transaction/README.md | 15 ++++ 13 files changed, 418 insertions(+), 47 deletions(-) create mode 100644 crates/agent-windows/examples/passive_state.rs create mode 100644 crates/agent-windows/tests/native_acl.rs create mode 100644 docs/platform-support.md create mode 100644 migrations/0013_windows_inventory_scope.sql create mode 100644 tests/windows_inventory_migration.py diff --git a/README.md b/README.md index 0163090..da01eda 100644 --- a/README.md +++ b/README.md @@ -1,20 +1,26 @@ -# Rust Discovery / RMM — Linux-MVP und Windows-Vorbereitung +# Rust Discovery / RMM — Linux-MVP und Windows-Client -> **Entwicklung wiederaufgenommen (2026-11-13).** Der Server zieht auf ausdrücklichen -> Userwunsch auf einen dedizierten Internetserver um; der Entwickler-PC dient +> **Entwicklung wiederaufgenommen (2026-11-13).** Der endgültige Server läuft auf +> `discovery.ease-technologies.de`; 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 +> Cloud-Linux-VM und eigenständiger Windows-11-Gast sind die Testclients. Topologie und > Deploymentstand: [docs/server-deployment.md](docs/server-deployment.md). > Die lokalen Serverbefehle und Slice-Beschreibungen unten sind historisch. **Aktuell (Spezifikation 1.9):** Windows darf auf ausdrücklichen Userwunsch bereits -parallel entwickelt werden. Windows-11-VM per abgesichertem Reverse-SSH mit -Administratortoken erreichbar; noch kein RMM-Windows-Client installiert. +parallel entwickelt werden. Erster nativer Windows-Client als LocalService mit +mTLS/WSS, gespeichertem Inventar, zwei frischen Heartbeats und Mandantentrennung +auf der Windows-11-VM nachgewiesen. Sieben native Tests bestanden. +Keine Windows-Jobcapability, erster Build unsigniert. Linux-Cloud-Agent, getrennte API/Gateway-Rollen, echte WebUI-Genehmigung und native Basis-/Rootdienstjobs sind nachgewiesen. APT-100-Ursache gefunden und -Provider-/Sandboxkorrektur nativ als Readiness geprüft; Paketabnahme selbst -bleibt offen. Aktueller Stand: [Implementierungsstand](docs/implementation-status.md), -[Windows-Entwicklungszugang](deploy/windows/README.md). +Provider-/Sandboxkorrektur nativ als Readiness geprüft. Neuer einzeln WebUI- +genehmigter Versuch entpackte Fixture 1.0, aber konfigurierte sie nicht: +**unknown**, keine Acceptance, keine weitere Paketwirkung. Configure-Korrektur +lokal geprüft, nicht auf Cloud installiert. Aktueller Stand: +[Implementierungsstand](docs/implementation-status.md), +[Windows-Client](deploy/windows/CLIENT.md), [Plattformmatrix](docs/platform-support.md), +[Entwicklungszugang](deploy/windows/README.md). ## Historischer erster passiver Slice diff --git a/crates/agent-windows/examples/passive_state.rs b/crates/agent-windows/examples/passive_state.rs new file mode 100644 index 0000000..6c5dc4b --- /dev/null +++ b/crates/agent-windows/examples/passive_state.rs @@ -0,0 +1,27 @@ +//! Development-only read-only receipt inspection. No network, grants or effects. +#[cfg(windows)] +fn main() -> anyhow::Result<()> { + let root = std::path::Path::new(r"C:\ProgramData\RustDiscovery\state"); + rmm_agent_windows::native::private_path(root, true)?; + let path = root.join("telemetry.sqlite"); + rmm_agent_windows::native::private_path(&path, false)?; + let db = + rusqlite::Connection::open_with_flags(path, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY)?; + let count: u64 = db.query_row("SELECT count(*) FROM events", [], |r| r.get(0))?; + let sequence: u64 = + db.query_row("SELECT value FROM metadata WHERE key='sequence'", [], |r| { + r.get(0) + })?; + let agent: String = db.query_row("SELECT agent FROM identity", [], |r| r.get(0))?; + let integrity: String = db.query_row("PRAGMA integrity_check", [], |r| r.get(0))?; + println!( + "{}", + serde_json::json!({"agent_id":agent,"pending_inventory_events":count,"sequence":sequence,"integrity":integrity,"read_only":true}) + ); + Ok(()) +} +#[cfg(not(windows))] +fn main() { + eprintln!("Windows-only receipt probe"); + std::process::exit(1); +} diff --git a/crates/agent-windows/tests/native_acl.rs b/crates/agent-windows/tests/native_acl.rs new file mode 100644 index 0000000..ac14a61 --- /dev/null +++ b/crates/agent-windows/tests/native_acl.rs @@ -0,0 +1,69 @@ +#![cfg(windows)] +use anyhow::{Result, ensure}; +use rmm_agent_windows::native::{private_path, service_sid, wide}; +use std::{path::Path, ptr}; +use windows_sys::Win32::{ + Foundation::LocalFree, + Security::{ + Authorization::ConvertStringSecurityDescriptorToSecurityDescriptorW, + DACL_SECURITY_INFORMATION, OWNER_SECURITY_INFORMATION, PROTECTED_DACL_SECURITY_INFORMATION, + SetFileSecurityW, + }, +}; +fn apply(path: &Path, sddl: &str) -> Result<()> { + let text = wide(sddl); + let name = wide(path); + let mut descriptor = ptr::null_mut(); + // SAFETY: Windows parses a test-owned SDDL into one owned descriptor. + ensure!( + unsafe { + ConvertStringSecurityDescriptorToSecurityDescriptorW( + text.as_ptr(), + 1, + &mut descriptor, + ptr::null_mut(), + ) + } != 0, + "TEST_DESCRIPTOR" + ); + let result = unsafe { + SetFileSecurityW( + name.as_ptr(), + OWNER_SECURITY_INFORMATION + | DACL_SECURITY_INFORMATION + | PROTECTED_DACL_SECURITY_INFORMATION, + descriptor, + ) + }; + unsafe { + LocalFree(descriptor.cast()); + } + ensure!(result != 0, "TEST_ACL_APPLY"); + Ok(()) +} +#[test] +fn actual_windows_acl_rejects_broad_null_and_reparse_paths() { + // Explicit development VM test. Only a new empty temporary directory and + // its dummy nonsecret file are touched; never the running device identity. + let root = std::env::temp_dir().join(format!("rmm-private-acl-{}", uuid::Uuid::new_v4())); + std::fs::create_dir(&root).unwrap(); + let sid = service_sid().unwrap(); + let strict = format!("O:BAD:P(A;OICI;FA;;;SY)(A;OICI;FA;;;BA)(A;OICI;0x1301bf;;;{sid})"); + apply(&root, &strict).unwrap(); + private_path(&root, true).unwrap(); + let file = root.join("dummy.txt"); + std::fs::write(&file, b"nonsecret fixture").unwrap(); + private_path(&file, false).unwrap(); + assert!(private_path(&file, true).is_err()); + apply(&file, "O:BAD:P(A;;FA;;;SY)(A;;FA;;;BA)(A;;FR;;;BU)").unwrap(); + assert!(private_path(&file, false).is_err()); + apply(&file, "O:BAD:NO_ACCESS_CONTROL").unwrap(); + assert!(private_path(&file, false).is_err()); + apply(&file, &strict).unwrap(); + let link = root.join("dummy-link.txt"); + std::os::windows::fs::symlink_file(&file, &link).unwrap(); + assert!(private_path(&link, false).is_err()); + std::fs::remove_file(link).unwrap(); + std::fs::remove_file(file).unwrap(); + std::fs::remove_dir(root).unwrap(); +} diff --git a/deploy/cloud_server_upgrade.py b/deploy/cloud_server_upgrade.py index dcc1e49..149a466 100644 --- a/deploy/cloud_server_upgrade.py +++ b/deploy/cloud_server_upgrade.py @@ -84,6 +84,12 @@ def deploy(payload): require(json.loads((backup/'build-result.json').read_text())['exit_code'] == 0, 'build must pass') require(all(hashlib.sha256((root/name).read_bytes()).hexdigest() == sha for name,sha in record['files'].items()), 'source drift') require(not (backup/'deploy-result.json').exists(), 'deployment already recorded') + if payload.get('closed_policy_sha256'): + import datetime as dt + policy = (root/'devstate/root-policy/policy.json').read_bytes() + require(hashlib.sha256(policy).hexdigest() == payload['closed_policy_sha256'] and + dt.datetime.fromisoformat(json.loads(policy)['expires_at']) < dt.datetime.now(dt.timezone.utc), + 'known unknown requires closed root policy') raw = base64.b64decode(payload['web_tar'], validate=True) require(hashlib.sha256(raw).hexdigest() == payload['web_sha256'], 'reviewed web archive hash') # Publish immutable hashed assets before index, keeping the bind-mounted @@ -118,6 +124,7 @@ def deploy(payload): def main(): parser = argparse.ArgumentParser(description=__doc__); parser.add_argument('action', choices=('stage','status','deploy')); parser.add_argument('--id') + parser.add_argument('--preserve-known-unknown', action='store_true', help='Windows inventory migration only; preserve exact fenced APT evidence') args = parser.parse_args(); os.umask(0o077); STATE.mkdir(mode=0o700, parents=True, exist_ok=True) if args.action == 'stage': names = ['Cargo.toml','Cargo.lock','rust-toolchain.toml','deploy/Dockerfile','deploy/linux/rmm-apt-helper.service', @@ -135,11 +142,26 @@ def main(): print(dict(id=ident, launched=result['launched'], deployed=False)) else: ident = str(uuid.UUID(args.id)); cloud.contract.protected_json(STATE/(ident+'.json')) + before = None; payload = dict(id=ident) if args.action == 'deploy': target = cloud.contract.protected_json(cloud.ROOT/'devstate/remote-vm.json')['identity'] gate = cloud.bootstrap.rpc('server.conf', cloud.server, dict(kind='gate', tenant_id=cloud.TENANT, agent_id=target['agent_id'])) - require(gate['unresolved'] == 0, 'unresolved cloud job; no server switch') - payload = dict(id=ident) + if args.preserve_known_unknown: + import cloud_apt_retry as apt + checkpoint = cloud.contract.protected_json(apt.STATE/'apt_install_retry/checkpoint.json') + job = checkpoint['plan']['jobs'][0] + require(checkpoint['stage'] == 'unknown' and checkpoint['audit']['simulation'] is True and + gate == dict(jobs=13, outbox=13, permits=12, unresolved=1), 'one exact known unknown required') + current = cloud.Backend().call('jobs.get', dict(tenant_id=cloud.TENANT, job_id=job['job_id'])) + require(current['state'] == 'unknown' and current['attempt_id'] == job['attempt_id'], 'same unknown attempt required') + before = cloud.bootstrap.rpc('linux-vm.conf', apt.stored_attempt_evidence, + dict(job_id=job['job_id'], attempt_id=job['attempt_id'])) + require(before['ledger']['unresolved'] == 1 and before['ledger']['consumed'] == 9 and + before['ledger']['result'] is None and before['ledger']['outcome']['error_code'] == 'DPKG_INCONSISTENT', 'preserve exact native unknown') + closed = cloud.contract.protected_json(apt.STATE/'policy-closed.json') + payload['closed_policy_sha256'] = closed['policy_sha256'] + require((cloud.ROOT/'migrations/0013_windows_inventory_scope.sql').is_file(), 'additive Windows migration only') + else: require(gate['unresolved'] == 0, 'unresolved cloud job; no server switch') if args.action == 'deploy': stream = io.BytesIO() with tarfile.open(fileobj=stream, mode='w:') as archive: @@ -149,6 +171,15 @@ def main(): archive.add(p, arcname=str(p.relative_to(cloud.ROOT/'web/dist')), recursive=False) data = stream.getvalue(); payload.update(web_tar=base64.b64encode(data).decode(), web_sha256=hashlib.sha256(data).hexdigest()) result = cloud.bootstrap.rpc('server.conf', status if args.action == 'status' else deploy, payload) + if before is not None: + after = cloud.bootstrap.rpc('linux-vm.conf', apt.stored_attempt_evidence, + dict(job_id=job['job_id'], attempt_id=job['attempt_id'])) + gate_after = cloud.bootstrap.rpc('server.conf', cloud.server, dict(kind='gate', tenant_id=cloud.TENANT, agent_id=target['agent_id'])) + current = cloud.Backend().call('jobs.get', dict(tenant_id=cloud.TENANT, job_id=job['job_id'])) + require(before == after and gate_after == gate and current['state'] == 'unknown' and current['attempt_id'] == job['attempt_id'], + 'unknown evidence or execution artifacts changed during Windows migration') + cloud.contract.write_private(STATE/(ident+'.unknown-preserved.json'), dict(evidence=after, gate=gate_after, result=current)) + result['unknown_attempt_preserved'] = True print(result) diff --git a/deploy/windows/CLIENT.md b/deploy/windows/CLIENT.md index a7beee4..156bce4 100644 --- a/deploy/windows/CLIENT.md +++ b/deploy/windows/CLIENT.md @@ -29,9 +29,9 @@ Große PowerShell-Console-JSON-Eingaben waren als Bootstraptransport ungeeignet Artefaktverzeichnisse werden nach Hash neu angelegt, keine vorhandene Identität oder Historie gelöscht. Private Evidenz: `devstate/windows-client/`. -## Implementiert, Dienst-/Online-Abnahme noch offen +## Nativer Dienst, Inventar und verbleibender Umfang -- Nativer SCM-Dienstlebenszyklus, vorgesehen als `LocalService` mit eigenem +- Nativer SCM-Dienstlebenszyklus als `LocalService` mit eigenem Service-SID-Zugriff auf Zustand und ausschließlich lesbarem Programm/Config. - Windows prüft Owner/DACL und verweigert Reparse-Points/breite ACLs. Geräteschlüssel werden nur auf Windows erzeugt; Enrollment über CA- und namensgeprüftes TLS, @@ -45,11 +45,48 @@ oder Historie gelöscht. Private Evidenz: `devstate/windows-client/`. **Kein Jobexecutor, keine PowerShell-Jobfähigkeit, kein privilegierter Helper.** Angebote/Startgrants werden verweigert. Es gibt keine Genehmigungsabkürzung. +Tatsächlich installiert und gestartet: nativer SCM-Dienst mit eigenem Service-SID +unter `NT AUTHORITY\LocalService`; tatsächlicher Prozessowner `S-1-5-19`, nicht +Administrator/SYSTEM. Eigener Geräteschlüssel auf Windows erzeugt, einmaliges +Enrollment erfolgreich und Tokenkopie entfernt; mTLS-Hello und frischer Heartbeat +serverseitig bestätigt. Der erste `.ps1`-Aufruf wurde durch die lokale +Ausführungsrichtlinie vor jeder Installerwirkung verweigert. Verzeichnis, Dienst +und Identität waren nachweislich nicht angelegt; erst danach kontrollierte +Fortsetzung mit explizit **prozessbezogenem** `RemoteSigned` wie beim ursprünglichen +Bootstrap. Keine Änderung der Maschinen-/Gruppenrichtlinie, keine Jobausnahme. + +Native Rust-Testprogramme direkt über den gepinnten SSH-Zugang ausgeführt: +**3 Transporttests + 3 Bibliothekstests + 1 ACL-Integrationstest bestanden**. Diese prüfen Namens-/URL- +Validierung und sichere Fallbackauswahl, echte Windows-Inventardaten, zwei +unabhängige stabile Bootabfragen sowie SQLite-Reopen, monotone Sequenz, +Prozesssperre, gezielten ACK und Identitätsbindung. Der zusätzliche native ACL-Test +weist korrekte ACLs nach und verweigert breite ACLs, NULL-DACLs, falschen Pfadtyp +und Reparse-Points an ausschließlich neu erzeugten nichtgeheimen Tempfixtures. PowerShell-Pipelinewrapper +warteten bei nativen Testprogrammen; direkte native Ausführung lieferte Exit 0. + +Der tatsächliche Online-Lauf fand eine weitere echte Grenze: Migration 0001 +beschränkte `observations.source_id` auf `linux.base`. Daher bisher Heartbeats, +aber kein gespeichertes Windowsinventar. Additive Migration 0013 erweitert nur +diesen CHECK auf die beiden validierten Basisscopes. Echter isolierter PostgreSQL- +Test der Migrationen 1–13 bestanden: alte Linuxzeile bytegleich, Windows erlaubt, +beliebiger Scope verweigert, RLS bei fremdem/fehlendem Kontext und zusammengesetzter +Geräte-FK erhalten, keine Jobs/Outbox/Grants. Cloudmigration 0013 anschließend tatsächlich erfolgreich. Der ursprüngliche +Windows-Journaleintrag wurde ohne Neuerhebung/Identitätsreset erneut zugestellt +und gespeichert: ursprüngliches `observed_at` bleibt erhalten, `received_at` ist +separat. Geräte-API/MCP melden `source_id=windows.base`, korrektes Windowsinventar +und Inodes `null`; zwei verschiedene frische Heartbeats und `online` belegt. +Mandant B wurde sowohl für den A-Kontext als auch für seine eigene Mandantensicht +mit der fremden Asset-ID abgewiesen. Gerätespezifisch **0 Jobs / 0 Outbox / +0 Startgrants / 0 offene Versuche**. Keine WebUI-Genehmigung ausgeführt, weil diese +Strecke ausschließlich passive Standardbeobachtungen verarbeitet. + Dieser erste Entwicklungsbuild ist **unsigniert**. Kein produktiver signierter Installer/MSVC-Supportnachweis, keine Zertifikatsrotations-/Widerrufs-/Proxy- oder -Windows-Paket-/Dienstaktionsabnahme. Native Testprogramme sowie die tatsächliche -SCM-/Enrollment-/mTLS-/Inventarstrecke sind zum Zeitpunkt dieses Abschnitts noch -offen. Ein erfolgreicher Crossbuild bzw. `--native-probe` ersetzt sie nicht. +Windows-Paket-/Dienstaktionsabnahme. Der native Onlinenachweis verwendet WSS; +HTTPS-/Fallbackmodi sind gemeinsam implementiert, nativ auf Windows noch nicht +abgenommen. Die passive SCM-/Enrollment-/mTLS-/Inventar-/Mandantentrennungsstrecke sowie +die oben benannten nativen Tests sind nun tatsächlich getrennt belegt. +Dies ist keine vollständige Windows-/Linux-MVP-Abnahme. ## Ausgeführte und geplante Befehle @@ -58,8 +95,23 @@ Tatsächlich ausgeführt: Docker-Build und gezielte Rust-Prüfungen oben sowie und `python3 deploy/windows/client_bootstrap.py probe` gegen ausschließlich den Windows-Gast. Keine RMM-Jobs oder Genehmigungen wurden dabei erzeugt. -Geplant, noch nicht als bestanden behauptet: native Testprogramme und -`Install-PassiveClient.ps1` über `client_bootstrap.py install`, anschließend -zwei frische Heartbeats, korrekt zugeordnetes Inventar und Tenant-B-Verweigerung. +Zusätzlich tatsächlich ausgeführt: native `test-lib`/`test-bin`/`test-acl`, Installer nach +nachgewiesenem Nichtstart mit `install-after-nonstart` und die oben benannte +PostgreSQL-Migrationsprüfung sowie `passive-acceptance` gegen den Cloudserver +mit gespeichertem Inventar, zwei Heartbeats, Tenant-B-Verweigerung und Null-Jobgate. Installation ist create-only; bei Teilfehlern Zustand inspizieren und erhalten, nicht blind neu enrollen oder den Bootstrap wiederholen. + +Native ergänzende Receiptprüfung: das separate Entwicklungstool +`examples/passive_state.rs` öffnete ausschließlich die vorhandene Windows-SQLite +im Read-only-Modus. Integrität `ok`, feste Geräteidentität identisch, Sequenz 59, +**0 ausstehende Inventarereignisse**: der konkrete Server-ACK wurde lokal verbucht. +Keine neue Erhebung, kein Journalreset und kein neues Enrollment für diesen Nachweis. + +Bekannte Darstellungsgrenze des ersten Collectors: `os` enthält den tatsächlich +ausgelesenen Registry-Produktnamen samt DisplayVersion/Build. Auf dieser Windows- +11-Pro-VM lautet der historische Registrywert noch `Windows 10 Pro`, mit +`DisplayVersion=26H2; Build=26300`. Die unabhängige native CIM-Probe bestätigt +Windows 11 Pro. Der Registrywert wird nicht stillschweigend als Marketingversion +uminterpretiert; eine einheitliche, quellenbewusste OS-Bezeichnung ist noch offen. +Die aktuelle Capability bleibt deshalb ausdrücklich partielles Basisinventar. diff --git a/deploy/windows/client_bootstrap.py b/deploy/windows/client_bootstrap.py index 93565d3..97731c5 100644 --- a/deploy/windows/client_bootstrap.py +++ b/deploy/windows/client_bootstrap.py @@ -12,6 +12,7 @@ import os from pathlib import Path import subprocess import sys +import time ROOT = Path(__file__).resolve().parents[2] sys.path.insert(0, str(ROOT / 'deploy')) @@ -44,7 +45,7 @@ def powershell(script, payload=None, timeout=60, remote_signed=False): UPLOAD = r''' $ErrorActionPreference='Stop' $p=([Console]::In.ReadLine() | ConvertFrom-Json) -if ($p.name -notmatch '^((rmm-agent-windows|windows-tests-(lib|bin))\.exe|Install-PassiveClient\.ps1)$') {throw 'Artifact allowlist'} +if ($p.name -notmatch '^((rmm-agent-windows|windows-tests-(lib|bin|acl))\.exe|Install-PassiveClient\.ps1|PassiveStateProbe\.exe)$') {throw 'Artifact allowlist'} $root='C:\ProgramData\RustDiscoveryBootstrap' if (!(Test-Path -LiteralPath $root)) { New-Item -ItemType Directory -Path $root | Out-Null @@ -67,7 +68,7 @@ if (Test-Path -LiteralPath $path) {throw 'Artifact already exists'} VERIFY_UPLOAD = r''' $ErrorActionPreference='Stop' $p=([Console]::In.ReadLine() | ConvertFrom-Json) -if ($p.sha256 -notmatch '^[0-9a-f]{64}$' -or $p.name -notmatch '^((rmm-agent-windows|windows-tests-(lib|bin))\.exe|Install-PassiveClient\.ps1)$') {throw 'Artifact allowlist'} +if ($p.sha256 -notmatch '^[0-9a-f]{64}$' -or $p.name -notmatch '^((rmm-agent-windows|windows-tests-(lib|bin|acl))\.exe|Install-PassiveClient\.ps1|PassiveStateProbe\.exe)$') {throw 'Artifact allowlist'} $path='C:\ProgramData\RustDiscoveryBootstrap\'+$p.sha256+'\'+$p.name $hash=(Get-FileHash -LiteralPath $path -Algorithm SHA256).Hash.ToLowerInvariant() if ($hash -cne $p.sha256) {throw 'Artifact hash'} @@ -84,18 +85,7 @@ $probe=$raw | ConvertFrom-Json $os=Get-CimInstance Win32_OperatingSystem -Property Caption,Version,OSArchitecture [pscustomobject]@{probe=$probe;os_caption=$os.Caption;os_version=$os.Version;architecture=$os.OSArchitecture;native_execution=$true} | ConvertTo-Json -Depth 8 -Compress ''' -TEST = r''' -$ErrorActionPreference='Stop' -$p=([Console]::In.ReadLine() | ConvertFrom-Json) -if ($p.kind -notin @('lib','bin')) {throw 'Test allowlist'} -if ($p.sha256 -notmatch '^[0-9a-f]{64}$') {throw 'Artifact hash format'} -$path='C:\ProgramData\RustDiscoveryBootstrap\'+$p.sha256+'\windows-tests-'+$p.kind+'.exe' -$out=& $path --test-threads=1 2>&1 -$code=$LASTEXITCODE -$summary=@($out | Where-Object {"$_" -match '^test result: '}) -if (!$summary) {throw 'No native test summary'} -[pscustomobject]@{exit_code=$code;native_execution=$true;summary=($summary -join ' ')} | ConvertTo-Json -Compress -''' + def record(name, evidence): @@ -131,12 +121,12 @@ def upload(path, name): def main(): parser=argparse.ArgumentParser() - parser.add_argument('action',choices=['upload-agent','upload-lib-tests','upload-bin-tests','upload-installer','install','install-after-nonstart','probe','test-lib','test-bin']) + parser.add_argument('action',choices=['upload-agent','upload-lib-tests','upload-bin-tests','upload-acl-tests','upload-installer','upload-state-probe','install','install-after-nonstart','passive-acceptance','probe','test-lib','test-bin','test-acl']) parser.add_argument('--artifact',type=Path) args=parser.parse_args() if args.action.startswith('upload-'): if args.artifact is None: parser.error('--artifact required') - name={'upload-agent':'rmm-agent-windows.exe','upload-lib-tests':'windows-tests-lib.exe','upload-bin-tests':'windows-tests-bin.exe','upload-installer':'Install-PassiveClient.ps1'}[args.action] + name={'upload-agent':'rmm-agent-windows.exe','upload-lib-tests':'windows-tests-lib.exe','upload-bin-tests':'windows-tests-bin.exe','upload-acl-tests':'windows-tests-acl.exe','upload-installer':'Install-PassiveClient.ps1','upload-state-probe':'PassiveStateProbe.exe'}[args.action] result=upload(args.artifact,name) print(json.dumps(result)) elif args.action in ('install','install-after-nonstart'): @@ -156,6 +146,35 @@ def main(): record(checkpoint+'.enrollment-token-hash.json',{'token_sha256':hashlib.sha256(material['token'].encode()).hexdigest(),'one_use':True}) result=powershell(script,{'sha256':artifact['sha256'],'token':material['token'],'ca':material['ca']},timeout=90,remote_signed=args.action=='install-after-nonstart') record('installed.json',result);print(json.dumps(result)) + elif args.action=='passive-acceptance': + import cloud_mvp_acceptance as cloud + import remote_client_bootstrap as bootstrap + identity=contract.protected_json(EVIDENCE/'service-initial-state.json')['identity'] + backend=cloud.Backend() + first=backend.call('inventory.get_device',{'tenant_id':cloud.TENANT,'asset_id':identity['asset_id']}) + contract.require(first['presence']=='online' and first['source_id']=='windows.base' and first['inventory'] is not None,'native_windows_inventory_required') + contract.require(set(first['capabilities'])=={'windows.base/1','heartbeat/1'} and first['inventory']['root_available_inodes'] is None,'honest_passive_capabilities') + deadline=time.monotonic()+75 + while True: + current=backend.call('inventory.get_device',{'tenant_id':cloud.TENANT,'asset_id':identity['asset_id']}) + if current['last_contact_at']!=first['last_contact_at']:break + contract.require(time.monotonic()