From 1fef7f6ce9614b40709f9ce547917c0241cc1122 Mon Sep 17 00:00:00 2001 From: Kevin Janssen Date: Fri, 13 Nov 2026 23:55:25 +0100 Subject: [PATCH] Qualify and activate persistent Windows automatic transport --- README.md | 29 ++- deploy/windows/CLIENT.md | 24 ++- deploy/windows/Install-PassiveClient.ps1 | 2 +- deploy/windows/activate_auto_transport.py | 219 ++++++++++++++++++++++ docs/handover.md | 59 +++++- docs/implementation-status.md | 18 ++ docs/platform-support.md | 2 +- docs/post-mvp.md | 15 +- docs/windows-gates.md | 2 +- tests/windows_activate_auto_transport.py | 105 +++++++++++ 10 files changed, 457 insertions(+), 18 deletions(-) create mode 100644 deploy/windows/activate_auto_transport.py create mode 100644 tests/windows_activate_auto_transport.py diff --git a/README.md b/README.md index a401f52..19cf1f7 100644 --- a/README.md +++ b/README.md @@ -69,10 +69,31 @@ erlaubte, sichtbar simulierte dev/test-Identität; das ist keine menschliche Produktionsfreigabe. MCP und Automatik können nicht genehmigen. Passive Standardinventur und Lesen gespeicherter Ergebnisse benötigen keinen Job. -Der Windows-Client ist als LocalService mit Enrollment, mTLS/WSS, gespeichertem -Inventar und Mandantentrennung nativ passiv geprüft; sieben native Tests -bestanden. Der Entwicklungsbuild ist unsigniert und hat keinen Jobexecutor. -Windowsausbau, weitere Agentplattformen, PVE/PBS/Cluster/Backups und Betriebsreife +Die Windows-11-VM wird auf eigenen Auftrag weiterentwickelt. Der passive +LocalService-Client ist mit Enrollment, mTLS, WSS und explizitem HTTPS, +gespeichertem Inventar, konkreten ACKs und Mandantentrennung nativ geprüft; +sieben native Tests bestanden. Automatischer HTTPS-Fallback nach zwei +gezielten authentisierten WSS-Abweisungen ist ebenfalls nachgewiesen; +Testhooks sind wieder geschlossen und die ursprüngliche WSS-Konfiguration +wurde unverändert wiederhergestellt. Danach wurde die bestehende VM separat +zustandserhaltend auf dauerhaft `transport=auto` umgestellt und nativ geprüft: +WSS bevorzugt, zwei frische Heartbeats und konkretes ACK, gleiche LocalService- +Identität und weiterhin keine Jobs. Dies ist keine neue Installationsabnahme. + +Separate native TLS-Proben als Bootstrapadministrator belegen falsche CA, +falschen Servernamen und ein abgelaufenes Clientzertifikat, mit gültiger +Kontrolle vor und nach den Ablehnungen. Das sind keine LocalService- +TLS-Negativnachweise. Der permanente Dienst und seine Geräteidentität blieben +erhalten; private Schlüssel verließen die VM nicht. + +Windows meldet weiterhin keine Jobcapability und hat keinen Jobexecutor. +Vertrauenswürdige Uhr, gemeinsamer signierter Sync-/Journal-/Einmalverbrauchskern +sowie plattformgebundene Interpreterpläne in Domain, Server und WebUI sind vor +dem ersten Windowsjob offen. Entwicklungsbuilds sind unsigniert; +Rotation, Widerruf, privilegierter Helper, Paketaktionen und Windows-Reboot +sind noch nicht abgenommen. Die [Windows-Gates](docs/windows-gates.md) und +[Grenze vor dem ersten Job](docs/windows-job-boundary.md) führen den nächsten +Umfang. Weitere Agentplattformen, PVE/PBS/Cluster/Backups und Betriebsreife folgen außerhalb des Linux-MVP. RustDesk ist ausdrücklich ausgelassen. ## Projektunterlagen diff --git a/deploy/windows/CLIENT.md b/deploy/windows/CLIENT.md index afedb9b..bfd6c8d 100644 --- a/deploy/windows/CLIENT.md +++ b/deploy/windows/CLIENT.md @@ -4,6 +4,26 @@ Stand 2026-11-13, Spezifikation 1.15. Windows-11-Gast und Notebook-Host sind verschiedene Geräte. Auf dem Notebook laufen ausschließlich Entwicklungstools; der Client verwendet den endgültigen Cloudserver `discovery.ease-technologies.de`. +## Aktueller Dienst dauerhaft auf Auto — 2026-11-13 + +Nach dem bestandenen Fallbacktest wurde die bestehende VM im separaten Fall +`422562e8-18eb-4865-977d-ab2af65f510b` dauerhaft auf `transport=auto` gestellt. +WSS bleibt bevorzugt; zwei frische WSS-Heartbeats und ein konkretes Inventar-ACK +sind unter dem tatsächlichen LocalService (`S-1-5-19`) nativ nachgewiesen. +Binary, Geräteidentität, CA, Zertifikat, Schlüssel, ACLs und Telemetriehistorie +blieben erhalten. Beide Server-Testhooks bleiben deaktiviert; Serverkonfiguration +und Rootpolicy wurden bei dieser Umstellung nicht verändert. Windows bleibt bei +0 Jobs/Outbox/Grants/ungeklärten Wirkungen, Linux unverändert bei 30/30/26/0. + +Der verifizierte geschützte Beleg liegt unter +`devstate/windows-client/auto-default/422562e8-18eb-4865-977d-ab2af65f510b/result.json`. +`devstate/windows-client/current-transport.json` bindet ihn per Hash und hält den +aktuellen Transport getrennt von historischen Abnahmen fest. Originalkonfiguration +und ACLs bleiben versioniert für eine ausdrückliche Wiederherstellung erhalten. +Die Installerquelle verwendet ebenfalls `auto`; eine frische Installation wurde +damit nicht ausgeführt. Fünf gezielte lokale Schutztests sowie Parserprüfungen +bestanden. Es wurden keine Windows-Jobs oder Reboots ausgeführt. + ## Automatischer WSS→HTTPS-Fallback nativ bestanden — 2026-11-13 Eigener Fall `2ff2e1aa-0037-4831-9bc2-31218bf1461c` auf derselben bestehenden @@ -29,8 +49,8 @@ Ausgeführt: `python3 deploy/windows/auto_transport_acceptance.py start Sechs gezielte lokale Guards ergänzen den nativen Nachweis; kein neuer Clientbuild und keine Windows-Syncbereitschaft erfunden. Geschützt: `devstate/windows-client/auto-transport/2ff2e1aa-0037-4831-9bc2-31218bf1461c/result.json`, -verifiziert. Aktueller Dienst nach dieser Abnahme wieder mit ursprünglichem WSS; -eine dauerhafte Defaultumstellung ist ein eigener dokumentierter Schritt. +verifiziert. Am Ende dieses Testfalls lief der Dienst wieder mit ursprünglichem +WSS. Die anschließende dauerhafte Auto-Umstellung ist oben separat dokumentiert. ## TLS-Negativfälle auf Windows nativ bestanden — 2026-11-13 diff --git a/deploy/windows/Install-PassiveClient.ps1 b/deploy/windows/Install-PassiveClient.ps1 index 553319a..e5d4b1a 100644 --- a/deploy/windows/Install-PassiveClient.ps1 +++ b/deploy/windows/Install-PassiveClient.ps1 @@ -72,7 +72,7 @@ $config = [ordered]@{ ca_file = $caPath state_directory = $state enrollment_token_file = $tokenPath - transport = 'wss' + transport = 'auto' } $configPath = Join-Path $root 'config.json' [IO.File]::WriteAllText($configPath, ($config | ConvertTo-Json -Compress), (New-Object Text.UTF8Encoding($false))) diff --git a/deploy/windows/activate_auto_transport.py b/deploy/windows/activate_auto_transport.py new file mode 100644 index 0000000..34dc837 --- /dev/null +++ b/deploy/windows/activate_auto_transport.py @@ -0,0 +1,219 @@ +#!/usr/bin/env python3 +"""Activate the already native-qualified passive Windows automatic transport. + +Only the existing service configuration changes. Historical acceptance reports +remain immutable. Ambiguous replies permit readback or explicit restoration of +that same transition, never a repeated enter or automatic re-enrollment. +""" +import argparse +import hashlib +import os +from pathlib import Path +import uuid + +import auto_transport_acceptance as auto + +base = auto.base +require = base.require +STATE = base.cb.EVIDENCE/'auto-default' +CURRENT = base.cb.EVIDENCE/'current-transport.json' + +# Independent re-derivation from the immutable, hash-pinned original bytes. +# No private identity/key bytes leave the guest. A missing entered receipt after +# a lost reply remains missing; current state and fresh contacts prove activation. +READ_TRANSITION = r''' +$ErrorActionPreference='Stop' +$p=([Console]::In.ReadLine() | ConvertFrom-Json) +if ([string]([guid]$p.id) -cne $p.id) {throw 'Fixed transition ID'} +$folder='C:\ProgramData\RustDiscoveryBootstrap\transport-'+$p.id +$allowed=@('S-1-5-18','S-1-5-32-544') +foreach($path in @($folder,(Join-Path $folder 'manifest.json'),(Join-Path $folder 'config-original.bin'))) { + $item=Get-Item -LiteralPath $path -Force + if (($item.Attributes -band [IO.FileAttributes]::ReparsePoint) -or (!$item.PSIsContainer -and $item.Length -gt 32768)) {throw 'Bounded fixed transition metadata'} + $acl=Get-Acl -LiteralPath $path + if ($acl.GetOwner([Security.Principal.SecurityIdentifier]).Value -notin $allowed) {throw 'Bootstrap metadata owner'} + $rules=@($acl.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier])) + if (!$rules.Count) {throw 'Missing restrictive DACL'} + foreach($r in $rules) {if ($r.AccessControlType -ne 'Allow' -or $r.IdentityReference.Value -notin $allowed) {throw 'Bootstrap metadata DACL'}} +} +function Digest([byte[]]$bytes) { + $sha=[Security.Cryptography.SHA256]::Create() + try {return ([BitConverter]::ToString($sha.ComputeHash($bytes))).Replace('-','').ToLowerInvariant()} finally {$sha.Dispose()} +} +$manifest=Get-Content -LiteralPath (Join-Path $folder 'manifest.json') -Raw | ConvertFrom-Json +$original=[IO.File]::ReadAllBytes((Join-Path $folder 'config-original.bin')) +$originalHash=Digest $original +if ($manifest.id -cne $p.id -or $manifest.mode -cne 'auto' -or $originalHash -cne 'ad396dfafe1d9764eb9840185d1e167d06e018799d6786218691e600a33ff589' -or $manifest.original_config_sha256 -cne $originalHash) {throw 'Qualified original transition binding'} +$text=[Text.Encoding]::UTF8.GetString($original) +$re=New-Object Text.RegularExpressions.Regex('("transport"\s*:\s*)"wss"') +if ($re.Matches($text).Count -ne 1) {throw 'Single original WSS field'} +$selected=[Text.Encoding]::UTF8.GetBytes($re.Replace($text,'${1}"auto"',1));$selectedHash=Digest $selected +if ($manifest.selected_config_sha256 -cne $selectedHash) {throw 'Independently derived automatic configuration'} +[pscustomobject]@{id=$manifest.id;mode=$manifest.mode;original_config_sha256=$originalHash;expected_auto_config_sha256=$selectedHash;original_acl_sha256=(Digest ([Text.Encoding]::UTF8.GetBytes($manifest.original_sddl)));before=$manifest.before;entered_receipt_present=(Test-Path -LiteralPath (Join-Path $folder 'receipt-entered.json'));read_only=$true} | ConvertTo-Json -Depth 12 -Compress +''' + + +def reference(path): + path = Path(path) + return dict(path=str(path.resolve()),sha256=hashlib.sha256(path.read_bytes()).hexdigest()) + + +def prior_result(ident): + path = auto.STATE/str(uuid.UUID(ident))/'result.json' + report = base.cb.contract.protected_json(path) + require(report['verified'] is True and report['case'] == 'automatic_fallback' + and report['no_jobs_or_approvals'] is True and report['no_reboot'] is True + and report['final_native']['agent_id'] == base.AGENT + and report['final_native']['asset_id'] == base.ASSET + and report['final_native']['transport'] == 'wss' + and report['final_native']['config_sha256'] == base.ORIGINAL_CONFIG + and report['counts']['windows'] == dict(jobs=0,outbox=0,permits=0,unresolved=0) + and auto.flags_disabled(report['server']), 'finished native fallback and original WSS restoration required') + return report,path + + +def transition(ident): + return base.cb.powershell(READ_TRANSITION,dict(id=ident)) + + +def publish_current(folder, mode, report_name): + report_path = folder/report_name + report = base.cb.contract.protected_json(report_path) + native = report['native'] + require(mode in ('auto','wss') and report['verified'] is True and native['transport'] == mode, + 'only a verified actual transport state may become current') + value = dict(schema_version=1,type='rmm.windows.current-transport',case_id=folder.name, + agent_id=base.AGENT,asset_id=base.ASSET,binary_sha256=base.BINARY, + transport=mode,config_sha256=native['config_sha256'],evidence=reference(report_path)) + if CURRENT.exists(): + previous = base.cb.contract.protected_json(CURRENT) + if previous == value:return + require(previous.get('type') == value['type'] and previous['agent_id'] == base.AGENT + and previous['asset_id'] == base.ASSET + and (previous['case_id'] == folder.name or previous['transport'] == 'wss'), 'preserve any other current activation') + backup = folder/('current-index-before-'+mode+'.json') + if not backup.exists():base.save(folder,backup.name,previous) + temporary = CURRENT.with_name('.current-transport-'+str(uuid.uuid4())+'.json') + base.cb.contract.write_private(temporary,value) + os.replace(temporary,CURRENT) + + +def finish(ident): + folder = STATE/str(uuid.UUID(ident));intent = base.cb.contract.protected_json(folder/'intent.json') + before = base.cb.contract.protected_json(folder/'before.json') + require(intent['case'] == 'activate_automatic_transport' and intent['id'] == ident + and intent['source_sha256'] == hashlib.sha256(base.SCRIPT.encode()).hexdigest(), 'same fixed configuration activation') + require(not (folder/'explicit-restore-intent.json').exists() and not (folder/'restore-result.json').exists(), + 'an explicit restoration is not a new automatic activation; never republish historical auto evidence') + completed = folder/'result.json' + if completed.exists(): + recorded = base.cb.contract.protected_json(completed) + require(recorded['verified'] is True, 'preserve completed activation') + current = base.remote(ident,'state',mode='auto',source_sha256=intent['source_sha256']) + base.preserved(before['native'],current) + require(current['transport'] == 'auto' and current['config_sha256'] == recorded['native']['config_sha256'] + and current['config_acl_sha256'] == before['native']['config_acl_sha256'] + and current['service_state'] == 'Running' and current['process_owner_sid'] == 'S-1-5-19' + and auto.status() == before['server'] and auto.scopes() == before['counts'], + 'completed historical activation must still match actual current config and closed server state') + publish_current(folder,'auto','result.json') + print('Retained completed automatic Windows transport activation '+ident) + return + derived = transition(ident) + require(derived['id'] == ident and derived['mode'] == 'auto' and derived['read_only'] is True + and derived['original_config_sha256'] == base.ORIGINAL_CONFIG + and derived['original_acl_sha256'] == before['native']['config_acl_sha256'], 'same preserved native transition and independently derived configuration') + base.preserved(before['native'],derived['before']) + current = base.remote(ident,'state',mode='auto',source_sha256=intent['source_sha256']) + base.preserved(before['native'],current) + require(current['transport'] == 'auto' and current['config_sha256'] == derived['expected_auto_config_sha256'] + and current['config_acl_sha256'] == before['native']['config_acl_sha256'] + and current['service_state'] == 'Running' and current['process_owner_sid'] == 'S-1-5-19', 'actual already activated automatic config; no repeated enter or service start') + online = base.wait_mode(ident,'wss',base.cb.contract.timestamp(intent['started_at']),before['central']['device']) + native = base.remote(ident,'state',mode='auto',source_sha256=intent['source_sha256']);base.preserved(before['native'],native) + require(native['transport'] == 'auto' and native['config_sha256'] == derived['expected_auto_config_sha256'] + and native['config_acl_sha256'] == before['native']['config_acl_sha256'] + and native['journal']['pending_inventory_events'] == 0 and native['journal']['sequence'] > before['native']['journal']['sequence'], + 'two actual preferred-WSS contacts with retained journal and concrete ACK') + flags = auto.status(); counts = auto.scopes(); inventory = base.read_device() + require(auto.flags_disabled(flags) and flags == before['server'] and counts == before['counts'], + 'no server mutation, transport fault, new job or grant on either target') + base.save(folder,'result.json',dict(verified=True,completed=True,case=intent['case'],id=ident, + native=native,online=online,transition=derived,inventory=inventory,server=flags,counts=counts, + no_jobs_or_approvals=True,no_reboot=True,permanent_transport='auto', + qualification=intent['qualification'])) + publish_current(folder,'auto','result.json') + print('PASS permanent passive Windows auto transport: actual preferred WSS/heartbeats/ACK, retained identity/ACLs, no server changes or jobs') + + +def start(qualified_case): + os.umask(0o077);STATE.mkdir(mode=0o700,parents=True,exist_ok=True) + qualified,path = prior_result(qualified_case) + if CURRENT.exists(): + previous = base.cb.contract.protected_json(CURRENT) + require(previous['transport'] == 'wss', 'already active automatic transport; inspect current index, never enter again') + ident = str(uuid.uuid4());folder = STATE/ident;folder.mkdir(mode=0o700) + source = hashlib.sha256(base.SCRIPT.encode()).hexdigest() + intent = dict(id=ident,case='activate_automatic_transport',mode='auto',started_at=base.cb.contract.now().isoformat(), + source_sha256=source,qualification=reference(path),no_jobs=True,no_reboot=True) + base.save(folder,'intent.json',intent) + native = base.remote(ident,'state',mode='auto',source_sha256=source) + base.preserved(qualified['final_native'],native) + central = auto.observe(ident);flags = auto.status();counts = auto.scopes() + require(native['transport'] == 'wss' and native['config_sha256'] == base.ORIGINAL_CONFIG + and native['journal']['pending_inventory_events'] == 0 and native['service_state'] == 'Running' + and auto.flags_disabled(flags) and counts == qualified['counts'], 'known settled original WSS configuration and closed fault hooks') + base.save(folder,'before.json',dict(native=native,central=central,server=flags,counts=counts)) + base.save(folder,'enter-intent.json',base.payload(ident,'enter','auto')) + try: + entered = base.remote(ident,'enter',mode='auto',source_sha256=source) + base.save(folder,'entered.json',entered) + except Exception as error: + base.save(folder,'enter-reply-incomplete.json',dict(error_class=type(error).__name__,same_case_preserved=True, + continuation='finish reads actual state; restore explicitly restores the same original config')) + raise + print('Activated Windows automatic transport case '+ident,flush=True) + finish(ident) + + +def restore(ident): + folder = STATE/str(uuid.UUID(ident));intent = base.cb.contract.protected_json(folder/'intent.json') + before = base.cb.contract.protected_json(folder/'before.json') + require(auto.scopes() == before['counts'], 'unchanged target job state before explicit restoration') + base.fixed_intent(folder,'explicit-restore-intent.json',dict(id=ident,expected_original_config_sha256=base.ORIGINAL_CONFIG)) + current = base.remote(ident,'state',mode='auto',source_sha256=intent['source_sha256']);base.preserved(before['native'],current) + if not (current['transport'] == 'wss' and current['config_sha256'] == base.ORIGINAL_CONFIG + and current['config_acl_sha256'] == before['native']['config_acl_sha256'] and current['service_state'] == 'Running'): + value = base.remote(ident,'restore',mode='auto',source_sha256=intent['source_sha256']) + base.save(folder,'explicit-restored-'+str(uuid.uuid4())+'.json',value) + online = base.wait_mode(ident,'wss',base.cb.contract.now(),before['central']['device']) + native = base.remote(ident,'state',mode='auto',source_sha256=intent['source_sha256']);base.preserved(before['native'],native) + require(native['transport'] == 'wss' and native['config_sha256'] == base.ORIGINAL_CONFIG + and native['config_acl_sha256'] == before['native']['config_acl_sha256'] and native['journal']['pending_inventory_events'] == 0, + 'same original config bytes/ACL and concrete inventory ACK') + result = folder/'restore-result.json' + if not result.exists():base.save(folder,result.name,dict(verified=True,id=ident,native=native,online=online,no_jobs=True,no_reboot=True)) + publish_current(folder,'wss',result.name) + print('PASS explicit restoration of original Windows WSS configuration; activation evidence retained') + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('action',choices=('start','finish','restore')) + parser.add_argument('--qualified-auto-case');parser.add_argument('--id') + args = parser.parse_args() + if args.action == 'start': + require(args.qualified_auto_case and not args.id, 'one finished native fallback qualification required') + start(args.qualified_auto_case) + else: + require(args.id and not args.qualified_auto_case, 'same retained activation ID required') + {'finish':finish,'restore':restore}[args.action](args.id) + + +if __name__ == '__main__': + try: + main() + except Exception as error: + message = str(error) + print('WINDOWS_AUTO_ACTIVATION_INCOMPLETE:'+(message if isinstance(error,base.cb.contract.GuardError) else type(error).__name__)) + raise SystemExit(2) from None diff --git a/docs/handover.md b/docs/handover.md index 2582442..f4c0f3e 100644 --- a/docs/handover.md +++ b/docs/handover.md @@ -1,4 +1,4 @@ -# Übergabe — Linux-MVP abgeschlossen, 2026-11-13 +# Übergabe — Linux-MVP abgeschlossen, Windows wird fortgesetzt **M0–M5 sind im vereinbarten begrenzten dev/test-Umfang vollständig nachgewiesen.** Spezifikation 1.15; aktueller Umfang und Grenzen stehen in @@ -10,7 +10,8 @@ sind historische Belege. - Der Linuxclient läuft ausschließlich auf der permanenten Ubuntu-24.04- x86-64-Cloud-VM gegen `discovery.ease-technologies.de`. Das Notebook hat keine RMM-Dienste oder RMM-Container und dient nur der Entwicklung. - Windows ist ein eigener, bisher passiv geprüfter Gast. + Windows ist ein eigener passiv geprüfter Gast; sein Ausbau ist ausdrücklich + beauftragt und ändert die abgeschlossene Linux-Abnahme nicht. - Nativ bestanden: Paketfixture 1.0→1.1 und beide eigenen Noops, drei aktive Offlinefälle, Doppelzustellung, ACK-Verlust, Agentcrash, Rootdienst und begrenzte Logs, TLS-Lifecycle/Fallback sowie genau ein genehmigter Reboot. @@ -45,9 +46,61 @@ sind historische Belege. Alle Genehmigungen sind tatsächliche WebUI-Interaktionen mit sichtbar simulierter dev/test-Identität, kein menschlicher Produktionsfreigabenachweis. Produktions-IdP, CI-Runner, Mehrgeräte- und Langzeitbetrieb sind nicht -abgenommen. Weitere Arbeit nur nach eigenem Auftrag; [Backlog](post-mvp.md). +abgenommen. Die folgende Windowsfortsetzung ist ausdrücklich beauftragt; +weitere Themen stehen im [Backlog](post-mvp.md). Zugänge und private Rohbelege bleiben gitignoriert. +## Aktuelle Windowsfortsetzung + +Der bestehende Windows-11-LocalService bleibt passiv: gleiche Geräteidentität, +Telemetriehistorie und Schlüssel; keine Jobs, Outbox oder Startgrants. Native +WSS-/Inventar-/Tenantnachweise und sieben Rusttests liegen vor. Explizites HTTPS +ist unter dem tatsächlichen LocalService mit zwei frischen Heartbeats und +konkretem Inventar-ACK geprüft. Anschließend wurde die ursprüngliche +WSS-Konfiguration samt ACLs wiederhergestellt und erneut nativ beobachtet. + +Auch automatischer WSS→HTTPS-Fallback ist nativ bestanden: genau zwei +zielgebundene mTLS-WSS503-Auditreceipts, danach frische HTTPS-Heartbeats und ACK. +Windows blieb bei 0 Jobs/Outbox/Grants/ungeklärten Wirkungen; der Linuxstand +30/30/26/0 blieb unverändert. Rootpolicy blieb erhalten, beide zentralen +Transporthooks sind aus; die ursprünglichen WSS-Bytes/ACLs wurden restauriert. +Geschützter Fall: `devstate/windows-client/auto-transport/2ff2e1aa-0037-4831-9bc2-31218bf1461c/`. + +Anschließend wurde die vorhandene VM separat dauerhaft auf `transport=auto` +umgestellt; WSS bleibt bevorzugter Kanal. Zwei frische WSS-Heartbeats und +konkretes ACK sind unter LocalService (`S-1-5-19`) nativ beobachtet. Agentbinary, +CA/Zertifikat/Schlüssel, Identität, ACLs und Telemetriehistorie sind erhalten; +Serverflags, Rootpolicy und Faultkonfiguration blieben unverändert. +Windows bleibt 0/0/0/0, Linux bleibt 30/30/26/0. Der geschützte +`devstate/windows-client/auto-default/422562e8-18eb-4865-977d-ab2af65f510b/result.json` +ist verifiziert und wird vom +separaten aktuellen Transportbeleg per Hash gebunden. Die Installerquelle hat +nun ebenfalls Default `auto`; daraus folgt kein neuer Fresh-Install-, MSVC- +oder Signiernachweis. + +Native TLS-Negativproben sind separat als Bootstrapadministrator bestanden: +falsche CA und falscher Name liefern konkrete Rustls-Zertifikatsfehler, +abgelaufene Clientzertifikate den Serveralert `CertificateExpired`; gültige, +unregistrierte Kontrollen davor/danach passieren TLS und erhalten HTTP401. +Private Fixturekeys entstanden auf der VM und wurden nicht exportiert. +Permanente Identität und Dienst blieben unverändert. Dies qualifiziert keinen +LocalService-Negativlauf und noch keine Rotation oder Widerrufsbehandlung. +Der erste Fehlerklassifikationslauf bleibt fehlgeschlagen erhalten; der +gezielte Retest verwendete dieselben öffentlichen Zertifikate und denselben +VM-Schlüssel mit korrigierter typisierter Fehlerkette. Timeoutbelege bleiben +separat erhalten und gelten nicht als Zertifikatsablehnung. +Geschützter Fall: `devstate/windows-client/tls-negative/7b190a5c-c928-4348-bd0d-c9698dad5417/`. + +Nächste Grenze ist weiterhin **vor jedem Windowsjob**: qualifizierte +vertrauenswürdige Uhr, gemeinsamer signierter Sync-/Checkpoint-/Grantverbrauch, +erhaltende Jobjournalmigration und plattformgebundene Interpreterverträge in +Domain, Server und WebUI. Keine Ausführungscapability aus Transporterfolg +ableiten, kein erstmaliges PowerShell-Hello als Bootstrap ausführen. Exakte +Voraussetzungen und offene Nachweise: [Windows-Gates](windows-gates.md), +[Jobgrenze](windows-job-boundary.md), [Clientvertrag](../deploy/windows/CLIENT.md). +Windows-Reboot, Rotation/Widerruf der permanenten Identität, SYSTEM-Helper und +Installationsaktionen haben hier keine Freigabe. + ## Historische Entwicklungsstände bis zum Abschluss diff --git a/docs/implementation-status.md b/docs/implementation-status.md index 9b98329..bc7a34c 100644 --- a/docs/implementation-status.md +++ b/docs/implementation-status.md @@ -1,5 +1,23 @@ # Tatsächlicher Implementierungsstand +## Windows: dauerhaftes Auto auf bestehender VM nativ bestanden — 2026-11-13 + +Separater Fall `422562e8-18eb-4865-977d-ab2af65f510b` verifiziert und abgeschlossen. +Der vorhandene Dienst läuft dauerhaft mit `transport=auto`, bevorzugt WSS und +bestätigt zwei frische WSS-Heartbeats sowie konkretes Inventar-ACK. Tatsächlicher +LocalService, Binary, Identität, CA/Zertifikat/Schlüssel, ACLs und Telemetriehistorie +blieben erhalten. Originalkonfiguration ist versioniert. Beide Server-Testhooks +sind aus; Serverkonfiguration und Rootpolicy blieben unverändert. Windows +weiterhin 0 Jobs/Outbox/Grants/ungeklärte Wirkungen, Linux weiterhin 30/30/26/0. + +Geschütztes `auto-default//result.json` ist durch den separaten aktuellen +Transportbeleg per Hash gebunden. Der Installerdefault lautet ebenfalls `auto`; +keine frische Installation, MSVC- oder Signierabnahme daraus ableiten. Fünf +gezielte lokale Schutztests und PowerShell-Parserprüfungen bestanden. Keine +Windows-Jobs, Genehmigungen, Reboots oder Erweiterung der Ausführungsrechte. +Der erste Windows-Job bleibt bis zur qualifizierten Uhr und dem gemeinsamen +signierten Jobkern offen; siehe [Windows-Gates](windows-gates.md). + ## Windows: automatischer WSS→HTTPS-Fallback nativ bestanden — 2026-11-13 Fall2ff2e1aa-0037-4831-9bc2-31218bf1461c verifiziert. Bestehender LocalService- diff --git a/docs/platform-support.md b/docs/platform-support.md index db53f9b..782bd30 100644 --- a/docs/platform-support.md +++ b/docs/platform-support.md @@ -9,7 +9,7 @@ abgenommen.** | Ziel | Build | Tatsächlicher nativer Nachweis | Offene Grenzen | | --- | --- | --- | --- | | Ubuntu 24.04 x86-64, Cloud-Linux-Client | Rust 1.99.1, GNU/glibc, Bookworm-Buildbasis; Agent-/Helperartefakte benötigen höchstens GLIBC 2.34; neue 1-GiB-Variante mit 126 lokalen Tests qualifiziert | systemd-Agent, mTLS/WSS und HTTPS/Auto-Fallback, TLS-Lifecycle, Inventar/Heartbeat; genehmigte Skript-/Rootdienst-/begrenzte Logstrecke, Doppelzustellung/ACK-Verlust; alle drei aktiven Offlinefälle und Prozessabbruch mit dauerhaftem Unknown, signiertem Abschluss und unabhängigem Zähler; begrenztes M4-Update 1.0→1.1 und beide 1.1-Noops; eigener einmaliger Reboot mit signiertem Abschluss; automatische Helper-Startwiederholung; aktuelle native APT-Kopienqualifikation; MCP-Endbericht mit sieben erfolgreichen Operationen und DoD-Endabgleich bestanden | Begrenztes dev/test-MVP M0–M5 abgeschlossen. Genau eine reale Ziel-VM, keine Mehrgeräte-/Mischplattform- oder Produktionsabnahme. Rebootrechte und APT-Endpunkt geschlossen; 18 Rootverbräuche abgeglichen, alte APT-Fehlschläge erhalten. | -| Windows 11 Pro, Build 26300, x86-64, eigener Gast | `x86_64-pc-windows-gnu` Crossbuild Debug/Release und Clippy bestanden | LocalService/Service-SID, Enrollment, ausgehendes mTLS/WSS sowie separat natives explizites HTTPS und automatischer WSS→HTTPS-Fallback nach zwei authentisierten503, gespeichertes `windows.base`, frische Heartbeats und konkrete Inventar-ACKs; Tenant-B-Verweigerung, sieben native Rusttests. HTTPS-Abnahme erhielt Identität/ACLs und restaurierte Original-WSS. Separate native Admin-TLS-Proben verweigerten falsche CA/Name und abgelaufenes Clientzertifikat bei gültigen Kontrollen. | Unsignierter Entwicklungsbuild. Kein Jobexecutor/Helper/PowerShell-/Paketpfad. Rotation/Widerruf, MSI/EXE, signierter Installer und Rebootpersistenz noch nicht nativ abgenommen. Registry-Produktname meldet noch den tatsächlichen Legacywert „Windows 10 Pro“; unabhängige CIM-Probe bestätigt Windows 11. | +| Windows 11 Pro, Build 26300, x86-64, eigener Gast | `x86_64-pc-windows-gnu` Crossbuild Debug/Release und Clippy bestanden | LocalService/Service-SID, Enrollment, ausgehendes mTLS/WSS sowie separat natives explizites HTTPS und automatischer WSS→HTTPS-Fallback nach zwei authentisierten503, gespeichertes `windows.base`, frische Heartbeats und konkrete Inventar-ACKs; Tenant-B-Verweigerung, sieben native Rusttests. Bestehende VM anschließend dauerhaft auf `auto` mit bevorzugtem WSS umgestellt und nativ geprüft; Identität/ACLs erhalten. Separate native Admin-TLS-Proben verweigerten falsche CA/Name und abgelaufenes Clientzertifikat bei gültigen Kontrollen. | Unsignierter Entwicklungsbuild. Kein Jobexecutor/Helper/PowerShell-/Paketpfad. Rotation/Widerruf, MSI/EXE, signierter Installer und Rebootpersistenz noch nicht nativ abgenommen. Installerdefault `auto` ohne neue Installationsabnahme. Registry-Produktname meldet noch den tatsächlichen Legacywert „Windows 10 Pro“; unabhängige CIM-Probe bestätigt Windows 11. | | Windows MSVC-Ziel | Geplant | Nicht ausgeführt | GNU-Build/-Lauf ist kein MSVC-Nachweis. | | ARM64-Agenten, weitere Windows-/Linux-Versionen | Nicht freigegeben | Keine entsprechende native Agentabnahme | Keine Supportableitung aus einem Compilerziel oder ARM64-Server. | | Ubuntu 26.04 ARM64, dedizierter Cloudserver | Native ARM64-Serverbuilds bestanden | API/Gateway/PostgreSQL, Migrationen 1–13 und Clientverbindungen auf `discovery.ease-technologies.de` | Öffentliche WebUI/OIDC und Produktionsbetrieb nicht abgenommen; Verwaltungs-UI nur über SSH-Tunnel. Kein ARM64-Agentnachweis. | diff --git a/docs/post-mvp.md b/docs/post-mvp.md index 318fe1a..427d999 100644 --- a/docs/post-mvp.md +++ b/docs/post-mvp.md @@ -1,21 +1,24 @@ # Entdeckungen und Aufgaben nach dem Linux-MVP -Stand 2026-11-13. Diese Liste erweitert den aktuellen Auftrag nicht. Erst die -[M0–M5-Gates](mvp-gates.md) abschließen; neue Entdeckungen hier einordnen, -anstatt nebenbei weitere Produkteigenschaften zu bauen. Sicherheits- oder -Korrektheitsfehler in einem aktuellen MVP-Pfad bleiben dort sofort relevant. +Stand 2026-11-13. Die begrenzten Linux-[M0–M5-Gates](mvp-gates.md) sind +abgeschlossen. Windows wird auf eigenen Auftrag fortgesetzt; seine aktuellen +Voraussetzungen stehen in [Windows-Gates](windows-gates.md) und +[Jobgrenze](windows-job-boundary.md). Diese Liste erweitert den Auftrag nicht. +Weitere Entdeckungen hier einordnen, anstatt nebenbei Produkteigenschaften +zu bauen. Sicherheits- oder Korrektheitsfehler in einem aktuell bearbeiteten +Pfad bleiben dort sofort relevant. | Entdeckung / späteres Thema | Tatsächlicher heutiger Stand | Spätere Aufgabe | | --- | --- | --- | | Windows-Produktname | Reale Windows-11-Pro-VM meldet über RegistryProductName den Legacywert „Windows 10 Pro“; unabhängige CIM-Probe bestätigt Windows 11. Rohquelle wird nicht umgedeutet. | Windows-OS-Anzeige über geeignete versionierte Quellen normalisieren und Herkunft weiter sichtbar halten. Keine ungeprüfte Buildnummern-Heuristik. | -| Vollständiger Windows-Client (W) | Passiver LocalService-/Enrollment-/mTLS-WSS-/Inventar-/Tenantpfad und sieben native Tests bestanden. Kein Windows-Jobexecutor; Entwicklungsbuild unsigniert. | Native HTTPS-/Rotation-/Widerrufs-/Rebootpersistenz, eingeschränkter Helper, PowerShell und geprüfte MSI/EXE, MSVC-/Signier-/Installerabnahmen im ausdrücklich gewählten Windowsumfang. Kein Linux-MVP-Blocker. | +| Vollständiger Windows-Client (W) | Passiver LocalService-/Enrollment-/mTLS-WSS-/HTTPS-/Inventar-/Tenantpfad, automatischer HTTPS-Fallback und sieben native Tests bestanden. Bestehende VM separat mit dauerhaftem Auto-Default und bevorzugtem WSS nativ geprüft; keine neue Installationsabnahme. Separate Admin-TLS-Negativproben bestanden; keine LocalService-Negativprobe. Kein Windows-Jobexecutor; Entwicklungsbuild unsigniert. | Zuerst die ausdrücklich beauftragte Windows-Jobgrenze qualifizieren: Clock, gemeinsamer signierter Sync-/Journal-/Einmalverbrauchskern und Interpreterbindung. Rotation/Widerruf, Rebootpersistenz, Helper, geprüfte MSI/EXE sowie MSVC-/Signier-/Installerabnahmen folgen nur im gewählten Windowsumfang. Kein Linux-MVP-Blocker. | | Breitere Paket-/Updateunterstützung | Aktuelle APT-Abnahme betrifft ausschließlich die beiden gepinnten Testrezepte, nicht beliebige Pakete/Repositories oder OS-/Kernelupdates. | Weitere tatsächlich benötigte Rezepte und Plattformmatrix mit eigener Herkunfts-/Closure-/Nativeabnahme hinzufügen; keine Erweiterung durch frei gewählte URL/Installerargumente. | | Produktionsanmeldung und öffentliche Verwaltung | Explizites dev/test-Profil und sichtbar simulierte UI-Bedienung; Verwaltungszugang über SSH-Tunnel. Externer IdP/öffentliche Produktionsverwaltung nicht abgenommen. | OIDC-/MFA-/Betriebsprofil mit echtem Betreiber und getrennten Nachweisen konfigurieren/abnehmen. Keine öffentliche Dev-Anmeldung. | | Dauerhafter Produktivbetrieb (M7) | Ein dedizierter Cloudserver, getrennte API/Gateway-Rollen, interne DB; Wiederanläufe ohne Historienreset belegt. | HA, getestete Backups/zentraler Restore, vereinbarte RTO/RPO, externe Plattformüberwachung, signierte Agentupdates und getrennt gesicherter Auditbestand. Grundlegende aktuelle Wiederholungssperren bleiben schon im MVP Pflicht. | | Gleichzeitiger Build und Deployment | Entdeckt beim Zustellungstest und inzwischen im aktuellen Upgradepfad behoben: eindeutiger Kandidatentag + aufgezeichneter Digest; nur explizites geprüftes Deploy bewegt den Runtimetag. Abgeschlossener nativer Build ließ Runtime unverändert. Historische Buildrunner bleiben getrennt zu prüfen. | Verfahren später auf alle Release-/Rollbacks-/CI-Pfade übertragen. Historische mutable Runner bis dahin nur ausdrücklich koordiniert verwenden. | | Monitoringausbau (M6a) | Präsenz, Quellen-/Datenalter und unbekannte Gesundheit werden getrennt dargestellt. | Sollservice-/Funktionschecks, Alarmdauer/Hysterese, Vorfälle und produktiver Metrikpfad samt nativen AT-28-Nachweisen; keine erfundenen Patchdaten. | | Langzeitjournale und Kompaktierung | Reale Sync-Historien erreichten64MiB nach zehn Rootverbräuchen. Isoliert reproduziert; auch die folgende256MiB-Grenze wurde im Rebootabschluss erreicht; Spec 1.15 setzt weiterhin endliche 1 GiB pro Datei. Native Kopier- und Artefakterhaltungsqualifikation bestanden, alle Historien erhalten. Volle/inkonsistente Journale sperren weiterhin neue Wirkungen. | Dokumentierte beidseitige Kompaktierung und Kapazitätsplanung; niemals stille Löschung von Unknown oder unbestätigten Ergebnissen. | -| Automatische Rückkehr von HTTPS zu WSS | Tatsächlicher Auto-Fallback nach zwei authentisierten WSS503 bestanden. Ein bestehender HTTPS-Aktor bleibt gegebenenfalls bestehen; operativer Agentneustart stellte WSS wieder her. | Nur bei produktivem Bedarf einen begrenzten, zustandserhaltenden Transportwechsel untersuchen; derzeit kein automatischer Switchback versprochen und kein zusätzliches MVP-Feature. | +| Automatische Rückkehr von HTTPS zu WSS | Tatsächlicher Auto-Fallback nach zwei authentisierten WSS503 bestanden. Auch der passive Windows-LocalService-Fallback ist nativ geprüft. Ein bestehender HTTPS-Aktor bleibt gegebenenfalls bestehen; operativer Agentneustart mit erhaltener Konfiguration stellte WSS wieder her. | Nur bei produktivem Bedarf einen begrenzten, zustandserhaltenden Transportwechsel untersuchen; derzeit kein automatischer Switchback versprochen und kein zusätzliches MVP-Feature. | | Dauerhaft ungültiges passives Inventar vor Reconnect-Sync | Der neue Recovery-Scope wurde zunächst vom zentralen Zeichenvalidator abgewiesen. Das unverändert persistierte Inventar wurde vor dem Sync erneut gesendet und blockierte so den Kanal; der unmittelbare MVP-Fix erlaubt ausschließlich diesen bekannten Linux-Scope. | Einen expliziten Umgang mit dauerhaft abgewiesener passiver Telemetrie untersuchen, der Originalbytes, Nachrichten-ID, Herkunft und Ablehnungsbeleg erhält und keine Bestätigung erfindet. Job-/Ergebnisjournale und unbekannte Wirkungen dürfen dabei niemals übersprungen werden. | | Weitere Plattformen / Skalierung | Ubuntu 24.04 x86-64 als Linux-Testclient; ARM64-Serverbuild ist kein ARM64-Agentnachweis. Nur eine tatsächliche Linux-Zielmaschine im aktuellen Aufbau. | Native Agentmatrix und realistische Last-/Mehrgeräteabnahmen erst zur vereinbarten Ausbaustufe erweitern; keine erfundenen Parallelitätszahlen. | | Proxmox/PBS/Cluster/Backups (M6b) | Kein Hypervisorzugang für eigenständige Gastagenten nötig; bewusst nicht Teil des Linux-MVP. | Separater späterer Integrationsauftrag mit eigenen ACL-/Discovery-/Backup-/Clusterabnahmen. | diff --git a/docs/windows-gates.md b/docs/windows-gates.md index f09564b..b10183c 100644 --- a/docs/windows-gates.md +++ b/docs/windows-gates.md @@ -9,7 +9,7 @@ bleibt eine eigenständige Abnahme. Dieser Bericht erweitert dessen Umfang nicht | --- | --- | --- | | Zugang | Gepinnter Reverse-SSH-Zugang zum Gast vorhanden; keine öffentliche Windows-SSH-Freigabe. Bestehender Agent bei Wiederaufnahme als LocalService laufend, Auto-Start, unveränderte Identität, kein Enrollmenttoken. | Zugang zeitlich begrenzt; keine automatische Verlängerung oder neue öffentliche Portfreigabe. | | Passiver Client | SCM-Dienst, Service-SID/ACLs, Enrollment/mTLS/WSS, Inventar mit Quelle/Zeit, Heartbeats und Mandantentrennung nativ bestanden; sieben native Rusttests. | Bestehende Identität und Telemetriehistorie bei allen weiteren Schritten erhalten. | -| HTTPS/Fallback | Explizites HTTPS unter bestehendem LocalService mit zwei frischen Heartbeats, Inventar-ACK und Tenantverweigerung nativ bestanden; ursprüngliche WSS-Bytes/ACLs restauriert,0Jobs/Grants. | Automatischer Fallback nach zwei tatsächlichen mTLS-WSS503 ebenfalls nativ bestanden; zwei frische HTTPS-Heartbeats/ACK, Hooks geschlossen, WSS exakt restauriert. Dauerhafte Defaultkonfiguration gesondert behandeln. | +| HTTPS/Fallback | Explizites HTTPS und automatischer Fallback nach zwei tatsächlichen mTLS-WSS503 unter LocalService nativ bestanden, jeweils mit frischen Heartbeats und Inventar-ACK. Testhooks geschlossen. Anschließend bestehende VM separat dauerhaft auf `auto` gestellt und bevorzugtes WSS erneut mit zwei frischen Heartbeats/ACK geprüft; Identität und ACLs erhalten, 0 Jobs/Grants. | Transportnachweise abgeschlossen; kein automatischer HTTPS→WSS-Switchback nachgewiesen. Installerdefault ebenfalls `auto`, aber keine neue Installationsabnahme. | | TLS-Lifecycle | Falsche CA, falscher Name und abgelaufenes Clientzertifikat mit gültigen Kontrollen nativ als getrennte Admin-TLS-Proben bestanden. Permanente Identität/Dienst unverändert. | Rotation und Widerruf noch gesondert sicher implementieren und prüfen. Permanente Identität nicht widerrufen oder ersetzen. | | Signierter Jobkern | Windows verweigert Jobangebote/Grants ausdrücklich und meldet keine Ausführungscapability. | Gemeinsamen Sync-/Checkpoint-/Einmalverbrauchskern portieren; vertrauenswürdige Uhr, Journalmigration ohne Reset, Schlüsselbindung und Fehlerpfade qualifizieren. | | PowerShell | Noch kein Executor oder freigegebener Interpreter. Server/UI lösen derzeit Linuxvarianten auf. | Exakte Windows-PowerShell-5.1-Bytes, Ausgabeencoding, Prozessgrenzen und unprivilegierte Ausführungsidentität binden. Erst nach vollständigem Antrag und tatsächlichem WebUI-Klick ausführen. | diff --git a/tests/windows_activate_auto_transport.py b/tests/windows_activate_auto_transport.py new file mode 100644 index 0000000..b0c7c4a --- /dev/null +++ b/tests/windows_activate_auto_transport.py @@ -0,0 +1,105 @@ +#!/usr/bin/env python3 +"""Focused local guards for passive automatic-default activation; no VM.""" +import copy +import hashlib +import pathlib +import sys +import tempfile +import unittest +from unittest.mock import patch + +ROOT=pathlib.Path(__file__).resolve().parents[1] +sys.path.insert(0,str(ROOT/'deploy/windows')) +import activate_auto_transport as activation + + +def native(mode='wss',sequence=7): + return dict(agent_id=activation.base.AGENT,asset_id=activation.base.ASSET,transport=mode, + config_sha256=activation.base.ORIGINAL_CONFIG if mode=='wss' else 'independently-derived-auto-config', + config_acl_sha256='original-acl',hashes={'key':'unchanged'},acl_sha256={'key':'unchanged'}, + telemetry_creation_ticks=5,service_state='Running',process_owner_sid='S-1-5-19', + journal=dict(integrity='ok',read_only=True,agent_id=activation.base.AGENT,sequence=sequence,pending_inventory_events=0)) + + +class ActivationGuards(unittest.TestCase): + def prepare(self,root,completed=False): + ident='11111111-1111-4111-8111-111111111111';folder=root/ident;folder.mkdir(mode=0o700) + source=hashlib.sha256(activation.base.SCRIPT.encode()).hexdigest() + activation.base.save(folder,'intent.json',dict(id=ident,case='activate_automatic_transport',source_sha256=source, + started_at='2026-11-13T00:00:00Z',qualification={'actual_earlier_case':'retained'})) + activation.base.save(folder,'before.json',dict(native=native(),central={'device':{}},server={'closed':'retained'},counts={'targets':'retained'})) + if completed: + activation.base.save(folder,'result.json',dict(verified=True,native=native('auto',8))) + return ident,folder + + def test_finish_after_lost_enter_reply_only_reads_proven_transition(self): + with tempfile.TemporaryDirectory() as tmp: + root=pathlib.Path(tmp);ident,folder=self.prepare(root) + derived=dict(id=ident,mode='auto',read_only=True,original_config_sha256=activation.base.ORIGINAL_CONFIG, + original_acl_sha256='original-acl',expected_auto_config_sha256='independently-derived-auto-config',before=native(),entered_receipt_present=False) + calls=[] + def remote(case,action,**kwargs): + calls.append(action);self.assertEqual(action,'state');return native('auto',8) + with patch.object(activation,'STATE',root),patch.object(activation,'CURRENT',root/'current.json'), \ + patch.object(activation,'transition',return_value=derived),patch.object(activation.base,'remote',side_effect=remote), \ + patch.object(activation.base,'wait_mode',return_value={'two_actual_contacts':'fixture'}), \ + patch.object(activation.auto,'status',return_value={'closed':'retained'}), \ + patch.object(activation.auto,'flags_disabled',return_value=True), \ + patch.object(activation.auto,'scopes',return_value={'targets':'retained'}), \ + patch.object(activation.base,'read_device',return_value={'stored':'fixture'}),patch('builtins.print'): + activation.finish(ident) + self.assertEqual(calls,['state','state']) + result=activation.base.cb.contract.protected_json(folder/'result.json') + self.assertTrue(result['verified']);self.assertFalse(result['transition']['entered_receipt_present']) + self.assertFalse((folder/'entered.json').exists()) + current=activation.base.cb.contract.protected_json(root/'current.json') + self.assertEqual(current['transport'],'auto') + self.assertEqual(current['config_sha256'],'independently-derived-auto-config') + + def test_arbitrary_observed_config_hash_cannot_publish_current(self): + with tempfile.TemporaryDirectory() as tmp: + root=pathlib.Path(tmp);ident,folder=self.prepare(root) + derived=dict(id=ident,mode='auto',read_only=True,original_config_sha256=activation.base.ORIGINAL_CONFIG, + original_acl_sha256='original-acl',expected_auto_config_sha256='independently-derived-auto-config',before=native()) + wrong=native('auto');wrong['config_sha256']='unknown-host-config' + with patch.object(activation,'STATE',root),patch.object(activation,'CURRENT',root/'current.json'), \ + patch.object(activation,'transition',return_value=derived),patch.object(activation.base,'remote',return_value=wrong): + with self.assertRaises(activation.base.cb.contract.GuardError):activation.finish(ident) + self.assertFalse((folder/'result.json').exists());self.assertFalse((root/'current.json').exists()) + + def test_restored_activation_cannot_republish_historical_automatic_index(self): + for marker in ('restore-result.json','explicit-restore-intent.json'): + with self.subTest(marker=marker),tempfile.TemporaryDirectory() as tmp: + root=pathlib.Path(tmp);ident,folder=self.prepare(root,completed=True) + activation.base.save(folder,marker,{'explicit_restore':'retained'}) + with patch.object(activation,'STATE',root),patch.object(activation,'CURRENT',root/'current.json'), \ + patch.object(activation.base,'remote',side_effect=AssertionError('no repeat transition')): + with self.assertRaises(activation.base.cb.contract.GuardError):activation.finish(ident) + self.assertFalse((root/'current.json').exists()) + + def test_completed_automatic_finish_checks_actual_config_before_index_repair(self): + with tempfile.TemporaryDirectory() as tmp: + root=pathlib.Path(tmp);ident,_=self.prepare(root,completed=True) + with patch.object(activation,'STATE',root),patch.object(activation,'CURRENT',root/'current.json'), \ + patch.object(activation.base,'remote',return_value=native('wss')): + with self.assertRaises(activation.base.cb.contract.GuardError):activation.finish(ident) + self.assertFalse((root/'current.json').exists()) + + def test_index_restore_versions_previous_auto_and_keeps_original_receipt(self): + with tempfile.TemporaryDirectory() as tmp: + root=pathlib.Path(tmp);ident,folder=self.prepare(root,completed=True) + activation.base.save(folder,'restore-result.json',dict(verified=True,native=native('wss',9))) + with patch.object(activation,'CURRENT',root/'current.json'): + activation.publish_current(folder,'auto','result.json') + before=(root/'current.json').read_bytes() + activation.publish_current(folder,'wss','restore-result.json') + after=(root/'current.json').read_bytes() + activation.publish_current(folder,'wss','restore-result.json') + self.assertEqual(after,(root/'current.json').read_bytes()) + self.assertNotEqual(before,after) + saved=activation.base.cb.contract.protected_json(folder/'current-index-before-wss.json') + self.assertEqual(saved['transport'],'auto') + self.assertTrue(activation.base.cb.contract.protected_json(folder/'result.json')['verified']) + + +if __name__=='__main__':unittest.main()