diff --git a/deploy/windows/console_access_precision.py b/deploy/windows/console_access_precision.py new file mode 100644 index 0000000..1d25088 --- /dev/null +++ b/deploy/windows/console_access_precision.py @@ -0,0 +1,101 @@ +#!/usr/bin/env python3 +"""New public console package correcting only the old AccountExpires guard. + +Local only: reads the immutable completed server-only recovery case and its +public package, never contacts Windows/server and cannot change a server lease. +The same active server expiry/key/pins remain bound. The old package is retained. +""" +import argparse +import json +import os +from pathlib import Path +import uuid +import zipfile + +import console_access_recovery as original + +require, sha, save = original.require, original.sha, original.save +STATE = original.cb.EVIDENCE / 'dev-access-console-precision-correction' +PARENT_ID = '4b6506a7-6c3e-4cca-a497-618fa8666300' +PARENT_SOURCE_SHA = '703fb5e4ae04d8555bad858c5d7b2ac4880e06d6fa951010acd43f7201a58053' +PARENT_INTENT_SHA = 'cd827d4056fb0045f23bff1fd9bd21b6137b53f063fe8215ad0945c2013cc44a' +PARENT_ENTER_SHA = '2185a88fc32db72119a584d84a46fb25cfca5f32f6e0c4ee5b7cf0728a361317' +PARENT_READBACK = 'readback-754e47df-25e0-4c0b-a411-56b3d350ace5.json' +PARENT_READBACK_SHA = 'f6e3f69a6cd4f006d00c90cadd8bfd47f94e954f1297bea5f6eecc4fd27d3787' +EXPIRY = '2026-11-15T13:05:58+00:00' +AUTHORIZED_SHA = 'fef4db300dd39fba9b52428817f453451c251c7768dd2fb6a76b39dd110dbbf2' +NAMES = ('Recover-ExistingDevAccess.ps1', 'public-recovery.json', 'README.txt') + + +def replace_once(text, old, new): + require(text.count(old) == 1, 'one exact reviewed precision/provenance replacement') + return text.replace(old, new, 1) + + +def corrected_script(source, ident): + require(str(uuid.UUID(ident)) == ident, 'new canonical console UUID') + # The original cfg bytes/hash and its exact expiry string have already been + # verified before this line. Derive ONE full 64-bit FILETIME, no rounding, + # alternative value, tolerance or claim of a measured VM account value. + old = "$account=Get-LocalUser -Name 'rmm-dev';if(!$account.Enabled-or!$account.AccountExpires-or$account.AccountExpires.ToUniversalTime().ToFileTimeUtc().ToString()-cne'134391345310000000'){throw 'Existing original expired account only'}" + new = "$expectedOldAccountFiletime=[DateTimeOffset]::Parse($cfg.expires_at).UtcDateTime.ToFileTimeUtc().ToString()\n$account=Get-LocalUser -Name 'rmm-dev';if(!$account.Enabled-or!$account.AccountExpires-or$account.AccountExpires.ToUniversalTime().ToFileTimeUtc().ToString()-cne$expectedOldAccountFiletime){throw 'Existing original expired account precision mismatch; stop for readonly inspection'}" + result = replace_once(source, old, new) + result = replace_once(result, "$recoveryId='" + PARENT_ID + "'", "$recoveryId='" + ident + "'") + result = replace_once(result, "@{id=$recoveryId;new_expiry=$newExpiry;original_config_sha256=", "@{id=$recoveryId;parent_server_case='" + PARENT_ID + "';parent_server_enter_sha256='" + PARENT_ENTER_SHA + "';new_expiry=$newExpiry;original_config_sha256=") + effect = '[IO.File]::Replace($candidate,$config,$nativeBackup)' + require(result.split(effect, 1)[1] == source.split(effect, 1)[1], 'all three mutation steps/start behavior unchanged') + require(result.count('Start-ScheduledTask -TaskName $taskName') == 1 and '134391345310000000' not in result, 'one original task start, no obsolete rounded guard') + return result + + +def parent(): + require(sha(original.__file__) == PARENT_SOURCE_SHA, 'immutable historical source, no rebase') + folder = original.STATE / PARENT_ID + require(sha(folder / 'intent.json') == PARENT_INTENT_SHA and sha(folder / 'server-entered.json') == PARENT_ENTER_SHA and sha(folder / PARENT_READBACK) == PARENT_READBACK_SHA, 'exact existing server-only CAS and independent readback') + intent = original.cb.contract.protected_json(folder / 'intent.json') + entered = original.cb.contract.protected_json(folder / 'server-entered.json') + readback = original.cb.contract.protected_json(folder / PARENT_READBACK) + require(intent['id'] == PARENT_ID and intent['source_sha256'] == PARENT_SOURCE_SHA and intent['payload']['new_expiry'] == EXPIRY and entered['completed'] is True and entered['authorized_sha256'] == readback['authorized_sha256'] == AUTHORIZED_SHA and entered['expiry'] == readback['expiry'] == '20261115130558Z' and readback['read_only'] is True and readback['completed'] is True, 'same already completed server lease; never a new CAS') + before = intent['payload']['server_before'] + require(all(readback[field] == before[field] for field in ('profile_sha256', 'effective_sha256', 'server_host_key_sha256', 'tunnel_public_key_sha256', 'uid', 'gid', 'home', 'shell')), 'original forwarding authority/key/profile/account unchanged') + for name, field in ((NAMES[0], 'console_sha256'), ('README.txt', 'readme_sha256'), ('public-recovery.json', 'public_json_sha256'), ('windows-dev-access-recovery.zip', 'bundle_sha256')): + require(sha(folder / name) == intent[field], 'immutable original public package files') + return folder, intent + + +def build(): + old_folder, old_intent = parent() + require(original.cb.contract.now() < original.dt.datetime.fromisoformat(EXPIRY), 'existing server lease still in its fixed window') + ident = str(uuid.uuid4()); folder = STATE / ident; folder.mkdir(mode=0o700, parents=True) + save(folder / 'prepare-intent.json', dict(id=ident, source_sha256=sha(__file__), parent_server_case=PARENT_ID, parent_server_enter_sha256=PARENT_ENTER_SHA, new_server_cas=False, no_windows_or_server_access=True)) + script = corrected_script((old_folder / NAMES[0]).read_text(), ident) + original.pair.write_bytes(folder / NAMES[0], script.encode()) + digest = original.pair.raw_sha(script.encode()) + public = dict(schema_version=1, id=ident, parent_server_case=PARENT_ID, parent_source_sha256=PARENT_SOURCE_SHA, parent_server_enter_sha256=PARENT_ENTER_SHA, parent_server_readback_sha256=PARENT_READBACK_SHA, new_expiry=EXPIRY, script_sha256=digest, no_private_keys=True, new_server_cas=False, old_account_guard='exact_derived_from_verified_config_utc_filetime', actual_vm_account_filetime_measured=False) + save(folder / 'public-recovery.json', public) + readme = (old_folder / 'README.txt').read_text() + require(old_intent['console_sha256'] in readme, 'original independent PS1 hash instructions') + readme = readme.replace(old_intent['console_sha256'], digest) + readme += ('\nPraezisionskorrektur: neues Konsolenpaket, neuer Fall ' + ident + '.\n' + 'Verwendet ausschliesslich den bereits bestaetigten Serverfall ' + PARENT_ID + ' und dieselbe UTC-Frist ' + EXPIRY + '. Keine neue Serververlaengerung.\n' + 'Der alte AccountExpires-Sollwert wird exakt aus der unveraenderten alten Config-UTC-Zeit einschliesslich Bruchteilen abgeleitet. Dies ist kein gemessener VM-Accountwert.\n' + 'Keine Rundung, Toleranz oder alternativer Sollwert. Bei Abweichung abbrechen und nur lesend pruefen lassen.\n' + 'Falls ein frueheres Paket bereits erfolgreich ausgefuehrt wurde: dieses Paket NICHT als Retry verwenden; der alte Config-Hashguard muss dann verweigern.\n') + original.pair.write_bytes(folder / 'README.txt', readme.encode()) + bundle = folder / 'windows-dev-access-recovery.zip' + with zipfile.ZipFile(bundle, 'x', compression=zipfile.ZIP_DEFLATED) as archive: + for name in NAMES: archive.write(folder / name, name) + bundle.chmod(0o600) + intent = dict(schema_version=1, id=ident, source_sha256=sha(__file__), parent_server_case=PARENT_ID, parent_intent_sha256=PARENT_INTENT_SHA, parent_server_enter_sha256=PARENT_ENTER_SHA, parent_server_readback_sha256=PARENT_READBACK_SHA, original_bundle_sha256=old_intent['bundle_sha256'], new_expiry=EXPIRY, console_sha256=digest, public_json_sha256=sha(folder / 'public-recovery.json'), readme_sha256=sha(folder / 'README.txt'), bundle_sha256=sha(bundle), no_windows_or_server_access=True, new_server_cas=False) + save(folder / 'intent.json', intent) + print(json.dumps(dict(id=ident, intent_sha256=sha(folder / 'intent.json'), bundle=str(bundle.resolve()), bundle_sha256=intent['bundle_sha256'], console_source=str((folder / NAMES[0]).resolve()), console_sha256=digest, new_expiry=EXPIRY, parent_server_case=PARENT_ID, new_server_cas=False, no_windows_or_server_access=True))) + + +def main(): + os.umask(0o077) + parser = argparse.ArgumentParser(description=__doc__); parser.add_argument('phase', choices=('build',)); parser.parse_args(); build() + + +if __name__ == '__main__': + try: main() + except Exception as error: print('CONSOLE_PRECISION_CORRECTION_INCOMPLETE:' + type(error).__name__); raise SystemExit(2) from None diff --git a/docs/windows-dev-access-recovery.md b/docs/windows-dev-access-recovery.md index 9a0594b..0edcde4 100644 --- a/docs/windows-dev-access-recovery.md +++ b/docs/windows-dev-access-recovery.md @@ -57,7 +57,8 @@ veränderte weder einen Downloadlease noch die RMM-Konfiguration. ## Öffentliches Paket und noch offene Userphase -Unter dem privaten Consolefall liegt ein öffentliches Paket mit genau +Unter dem privaten Consolefall liegt das **inzwischen zurückgezogene, +historisch erhaltene** öffentliche Paket mit genau `Recover-ExistingDevAccess.ps1`, `public-recovery.json` und `README.txt`. Es enthält öffentliche Pins und feste Parameter, keine privaten Schlüssel oder Tokens. Die Paketdateien sind zusätzlich im unveränderlichen Intent gebunden. @@ -68,6 +69,44 @@ Tokens. Die Paketdateien sind zusätzlich im unveränderlichen Intent gebunden. | `Recover-ExistingDevAccess.ps1` | `564da57d70ef06df7bd9adc37565b7e28ef446a6c69b984711c5b77b28441e8a` | | Consoleintent | `cd827d4056fb0045f23bff1fd9bd21b6137b53f063fe8215ad0945c2013cc44a` | +Vor der Userausführung fand Root im Konsolenguard eine unbelegte +Ganzsekundenannahme für den alten `AccountExpires`-Wert. Der feste Wert +`134391345310000000` ließ den Bruchteil `.254999` der ursprünglichen +Konfigurationszeit weg. Ein lokaler .NET-Roundtrip derselben vollständigen +UTC-Zeit ergibt `134391345312549990`. Das ist ein **abgeleiteter Sollwert**, +kein gemessener Windows-VM-Accountwert. Das alte Paket wird deshalb nicht zur +Ausführung weitergegeben; sein gültiger getrennter Server-CAS bleibt erhalten. + +Die kleine neue Quelle +[`console_access_precision.py`](../deploy/windows/console_access_precision.py) +mit SHA +`8b4d14edf0794c4ef662d7587b4538f8e7aebc06c11db76c3cafc2c24c11a37b` +erzeugte den neuen lokalen Consolefall +`5c96d3d8-1657-40c8-a6ec-c00b63a98210`. Sie bindet den ursprünglichen +Serverintent, Enterbeleg und getrennten Readback des Falls `4b6506…` sowie +sämtliche alten Paketdateihashes. Es gibt weder einen Serveraufruf noch eine +erneute Fristverlängerung: `2026-11-15T13:05:58+00:00` bleibt unverändert. + +Der neue Guard berechnet genau einen erwarteten 64-Bit-Wert über +`[DateTimeOffset]::Parse($cfg.expires_at).UtcDateTime.ToFileTimeUtc()` aus der +zuvor anhand der Originalbytes und der exakten alten Zeit geprüften Config. +Keine Rundung, Toleranz oder alternative Zeit wird akzeptiert. UUID und +Provenienzbeleg sind neu; die drei Mutationsschritte ab `File.Replace` bis +zum Ende sind gegenüber dem alten Paket bytegleich. Falls ein früheres Paket +entgegen dem bisherigen Kontrollstand bereits erfolgreich ausgeführt wurde, +muss der alte Config-Hashguard verweigern. Dann nur lesen und durch Root +abgleichen, kein neuer Versuch. + +| Neues Korrekturartefakt | SHA-256 | +| --- | --- | +| ZIP im Fall `5c96d3d8…` | `dbcd5ca863c0b09f89b67eb10eeaeaf89b941bbc5840079f1bb0c36dc6ff3b3e` | +| Neues `Recover-ExistingDevAccess.ps1` | `4977665fb092723998473f1c4be6685b1d93975176f8957bc3287d7e2f61cb69` | +| Neuer unveränderlicher Intent | `eae7995b5735bf1e8f0fafc0ae6ccf6bdd4576566663c1256a511f6c3408e32e` | + +Das Korrekturpaket ist lokal gebaut und geprüft; seine Veröffentlichung und +Userausführung sind damit noch nicht nachgewiesen. Die alten Quellen, ZIPs +und Fehlerbelege wurden nicht überschrieben. + Die Windows-Konsolenphase ist **noch nicht ausgeführt**. Sie prüft die alten Config-/Bootstrapbytes und öffentlichen Pins, den bestehenden Account sowie den unveränderten SYSTEM-Tunneltask. Erst bei `Ready` und ohne verbliebenen