From 6d4c75e88644fbca18959793402b8c00d5a7ee50 Mon Sep 17 00:00:00 2001 From: Kevin Janssen Date: Sat, 14 Nov 2026 19:40:40 +0100 Subject: [PATCH] Qualify isolated updater handoff contracts on cloud Linux --- deploy/updater_handoff_linux_acceptance.py | 181 ++++++++++++++++++++ docs/agent-updater-handoff-linux-results.md | 59 +++++++ docs/handover.md | 6 + docs/parallel-mvp-status.md | 7 +- 4 files changed, 251 insertions(+), 2 deletions(-) create mode 100644 deploy/updater_handoff_linux_acceptance.py create mode 100644 docs/agent-updater-handoff-linux-results.md diff --git a/deploy/updater_handoff_linux_acceptance.py b/deploy/updater_handoff_linux_acceptance.py new file mode 100644 index 0000000..bf6bc81 --- /dev/null +++ b/deploy/updater_handoff_linux_acceptance.py @@ -0,0 +1,181 @@ +#!/usr/bin/env python3 +"""Run only the frozen eight pure handoff contracts on the Cloud Linux VM. + +No RMM job, approval, agent/helper operation, release application or updater +installation. Prepare locally; execute one isolated nobody-owned process; +after any lost reply use read only. Original verifier runners remain unchanged. +""" +import argparse +import base64 +import hashlib +import inspect +import json +import os +from pathlib import Path +import subprocess +import uuid + +import windows_msi_runtime_acceptance as support + +ROOT = Path(__file__).resolve().parents[1] +UPDATER = ROOT.parent / 'rust-discovery-agent-updater' +STATE = ROOT / 'devstate/updater-handoff-native' +COMMIT = 'a2efb79' +RECEIPT_SHA = 'e924471166e68629d27d6adae51ebac05a77f04426cdd427e844a9dfb4920f70' +BINARY_SHA = '0c80a2107fff96d9e30aa02b1cb56071a0f7e2be2acb1bec6794324205af9c7a' +TESTS = sorted('''closed_service_sets_reject_omitted_full_and_apt_restart +event_chain_clock_limits_and_canonical_bytes_fail_closed +full_linux_three_service_handoff_replays_exactly_sixteen_events +full_renderer_binds_provisioned_file_key_without_inserting_it_into_raw_config +full_renderer_changes_only_named_hash_spans_preserving_all_other_raw_bytes +full_renderer_rejects_foreign_pins_unknown_duplicate_escaped_and_privilege_changes +health_is_domain_bound_fresh_evidence_and_never_opens_ready +no_ownership_before_stop_no_partial_pair_no_start_before_return'''.splitlines()) + + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + + +def remote(p): + import base64 + import hashlib + import json + import os + from pathlib import Path + import stat + import subprocess + import time + import uuid + + def require(ok, message): + if not ok: + raise RuntimeError(message) + + def enc(v): + return json.dumps(v, sort_keys=True, separators=(',', ':')).encode() + + def create(path, raw, mode=0o600): + fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, mode) + with os.fdopen(fd, 'wb') as f: + f.write(raw); f.flush(); os.fsync(f.fileno()) + fd = os.open(path.parent, os.O_DIRECTORY | os.O_RDONLY) + try: + os.fsync(fd) + finally: + os.close(fd) + + def run(args, timeout=20): + return subprocess.run(args, capture_output=True, timeout=timeout, + env={'PATH': '/usr/bin:/bin', 'LC_ALL': 'C', 'HOME': '/nonexistent'}) + + def witness(): + out = {'boot_id': Path('/proc/sys/kernel/random/boot_id').read_text().strip(), 'services': {}, 'files': {}} + for name, uid, binary in ( + ('rmm-agent-remote.service', 993, p['agent_sha256']), + ('rmm-helper-cloud.service', 0, p['helper_sha256']), + ('rmm-full-maintenance-helper.service', 0, p['helper_sha256'])): + r = run(['systemctl', 'show', name, '-p', 'ActiveState', '-p', 'MainPID', '-p', 'UnitFileState']) + require(r.returncode == 0, 'existing service read') + s = dict(line.split('=', 1) for line in r.stdout.decode().splitlines()) + pid = int(s['MainPID']); require(s['ActiveState'] == 'active' and pid > 1, 'three existing services active') + proc = Path('/proc', str(pid)); birth = (proc / 'stat').read_text().rsplit(') ', 1)[1].split()[19] + status = (proc / 'status').read_text().splitlines() + ids = {line.split(':')[0]: line.split()[1:] for line in status if line.startswith(('Uid:', 'Gid:'))} + image = hashlib.sha256((proc / 'exe').read_bytes()).hexdigest() + require(ids['Uid'] == [str(uid)] * 4 and ids['Gid'] == ['984'] * 4 and image == binary + and (proc / 'stat').read_text().rsplit(') ', 1)[1].split()[19] == birth, 'held generation/account/image') + out['services'][name] = dict(s, birth=birth, image=image, ids=ids) + r = run(['systemctl', 'show', 'rmm-apt-helper.service', '-p', 'ActiveState', '-p', 'UnitFileState']) + require(r.returncode == 0, 'APT service read') + apt = dict(line.split('=', 1) for line in r.stdout.decode().splitlines()) + require(apt == {'ActiveState': 'inactive', 'UnitFileState': 'disabled'}, 'APT remains closed') + out['apt'] = apt + for name in ('/etc/rmm-remote/helper-general.json', '/etc/rmm-remote/helper-full-maintenance.json', + '/etc/rmm-remote/full-maintenance-helper-proof.json', + '/etc/systemd/system/rmm-full-maintenance-helper.service'): + path = Path(name); m = path.lstat() + require(not path.is_symlink() and stat.S_ISREG(m.st_mode) and m.st_uid == 0 and not m.st_mode & 0o022 + and m.st_nlink == 1 and m.st_size < 65536, 'protected known control') + out['files'][name] = [m.st_dev, m.st_ino, m.st_uid, m.st_gid, m.st_mode, m.st_size, + m.st_mtime_ns, m.st_ctime_ns, hashlib.sha256(path.read_bytes()).hexdigest()] + for name in ('/var/lib/rmm-helper/consumption.sqlite', '/var/lib/rmm-helper/executor.lock', + '/var/lib/rmm-agent-remote/journal.sqlite', '/var/lib/rmm-agent-remote/consumption.sqlite'): + path = Path(name); m = path.lstat() + require(not path.is_symlink() and stat.S_ISREG(m.st_mode) and m.st_nlink == 1, 'existing state identity') + out['files'][name] = [m.st_dev, m.st_ino, m.st_uid, m.st_gid, m.st_mode] + return out + + require(os.geteuid() == 0 and os.uname().machine == 'x86_64', 'fixed Cloud Linux root bootstrap') + ident = str(uuid.UUID(p['id'])); require(ident == p['id'], 'canonical case') + folder = Path('/var/tmp') / ('rmm-updater-handoff-' + ident) + if p['action'] == 'read': + m = folder.lstat(); require(stat.S_ISDIR(m.st_mode) and not folder.is_symlink() and m.st_uid == 0, 'own original case') + return {'read_only': True, 'id': ident, 'entered': (folder / 'entered.json').exists(), + 'result': json.loads((folder / 'result.json').read_bytes()) if (folder / 'result.json').exists() else None, + 'current_witness': witness()} + require(p['action'] == 'execute', 'one exact unit action') + os.umask(0o022); folder.mkdir(mode=0o755) + create(folder / 'intent.json', enc({k: v for k, v in p.items() if k != 'binary_b64'})) + raw = base64.b64decode(p['binary_b64'], validate=True) + require(len(raw) == 2261368 and hashlib.sha256(raw).hexdigest() == p['binary_sha256'], 'fixed pure unit bytes') + binary = folder / 'handoff-contract'; create(binary, raw, 0o755) + before = witness(); create(folder / 'before.json', enc(before)) + command = ['/usr/bin/setpriv', '--reuid=65534', '--regid=65534', '--clear-groups', '--no-new-privs', str(binary)] + listed = run(command + ['--list', '--format', 'terse']) + create(folder / 'list.stdout', listed.stdout); create(folder / 'list.stderr', listed.stderr) + require(listed.returncode == 0 and listed.stderr == b'', 'native list succeeded') + require(sorted(line[:-6] for line in listed.stdout.decode().splitlines() if line.endswith(': test')) == p['tests'] + and len(listed.stdout.decode().splitlines()) == 8, 'exact eight native tests, no filter') + create(folder / 'entered.json', enc({'id': ident, 'run_once': True, 'time_ns': time.time_ns()})) + result = run(command + ['--test-threads=1', '--nocapture']) + create(folder / 'run.stdout', result.stdout); create(folder / 'run.stderr', result.stderr) + after = witness(); create(folder / 'after.json', enc(after)) + require(before == after and result.returncode == 0 and result.stderr == b'' + and b'8 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out' in result.stdout + and all((b'test ' + name.encode() + b' ... ok') in result.stdout for name in p['tests']), 'native eight and retained services/state') + receipt = dict(id=ident, passed=8, ignored=0, filtered=0, execution_uid=65534, tests=p['tests'], + before=before, after=after, binary_sha256=p['binary_sha256'], source_receipt_sha256=p['receipt_sha256'], + stdout_sha256=hashlib.sha256(result.stdout).hexdigest(), no_rmm_jobs=True, no_apply=True) + create(folder / 'result.json', enc(receipt)); return receipt + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('action', choices=('prepare', 'execute', 'read')); parser.add_argument('--case') + args = parser.parse_args(); os.umask(0o077); STATE.mkdir(mode=0o700, exist_ok=True) + if args.action == 'prepare': + support.require(args.case is None, 'new local case') + receipt = UPDATER / 'devstate/agent-updater-handoff/local-qualification-filekey.json' + support.private(receipt) + raw = receipt.read_bytes(); support.require(sha(raw) == RECEIPT_SHA, 'reviewed local receipt') + local = json.loads(raw) + for item in local['sources']: + blob = subprocess.check_output(['git', '-C', str(UPDATER), 'show', COMMIT + ':' + item['path']]) + support.require(len(blob) == item['bytes'] and sha(blob) == item['sha256'], 'exact committed qualified source') + binary = UPDATER / local['binary']['path']; support.require(sha(binary.read_bytes()) == BINARY_SHA, 'qualified binary') + ident = str(uuid.uuid4()); folder = STATE / ident; folder.mkdir(mode=0o700) + support.save(folder / 'intent.json', dict(id=ident, runner_sha256=sha(Path(__file__).read_bytes()), + receipt_sha256=RECEIPT_SHA, binary_sha256=BINARY_SHA, binary_path=str(binary), tests=TESTS, + agent_sha256='0a7ad6eefaefda79ee80b6a41b2df904e9e7f50ae6ebeed01b98c25b6ce5c06f', + helper_sha256='79442727c3ba31cda02a8bc0e67481f14db9f39fc07520a880a90b64f10f1eaf')) + else: + ident = str(uuid.UUID(args.case)); support.require(ident == args.case, 'same original case') + folder = STATE / ident; intent = support.load(folder / 'intent.json') + support.require(intent['runner_sha256'] == sha(Path(__file__).read_bytes()), 'original runner bytes') + if args.action == 'execute': + support.save(folder / 'execute-entered.json', {'once': True, 'no_retry': True}) + raw = Path(intent['binary_path']).read_bytes(); support.require(sha(raw) == BINARY_SHA, 'original binary') + intent['binary_b64'] = base64.b64encode(raw).decode() + payload = dict(intent, action=args.action) + code = 'import json\n' + inspect.getsource(remote) + '\nprint(json.dumps(remote(' + repr(payload) + ')))\n' + response = support.transport(support.access_settings(ROOT, 'linux'), 'python3 -', code.encode(), folder) + support.save(folder / (args.action + '-' + str(uuid.uuid4()) + '.json'), response) + if args.action == 'read': + support.require(response['result'] is not None and response['current_witness'] == response['result']['after'], 'readback retained native result') + print(json.dumps({'id': ident, 'action': args.action, 'passed': response.get('passed'), 'read_only': args.action == 'read'})); return + print(json.dumps({'id': ident, 'prepared_locally': True})) + + +if __name__ == '__main__': + main() diff --git a/docs/agent-updater-handoff-linux-results.md b/docs/agent-updater-handoff-linux-results.md new file mode 100644 index 0000000..5647130 --- /dev/null +++ b/docs/agent-updater-handoff-linux-results.md @@ -0,0 +1,59 @@ +# Updater-Handoffkernel: tatsächlicher Cloud-Linux-Nachweis + +2026-11-14. Ausschließlich der isolierte Kernel aus Commit +`a2efb79` wurde geprüft. Kein Installer, kein Agent-Selbstaustausch und keine +RMM-Jobgenehmigung sind Teil dieses Schritts. + +Der unabhängig geprüfte Runner `deploy/updater_handoff_linux_acceptance.py`, +SHA256 `502ba0d6f5a653dae21ddc871f069e61cbe4217d67e28708d1c0cad8347826f1`, +prüft die acht originalen Gitblobs gegen den lokalen Qualifikationsbeleg +`e924471166e68629d27d6adae51ebac05a77f04426cdd427e844a9dfb4920f70`. +Die native Unitexe hat2261368Byte und SHA256 +`0c80a2107fff96d9e30aa02b1cb56071a0f7e2be2acb1bec6794324205af9c7a`. +Später parallel bearbeitete Runtimequellen wurden nicht erneut gebaut oder als +bereits nativ qualifiziert behandelt. + +## Tatsächlich ausgeführt + +Fall `03ddcaa5-84a7-4722-bfd3-55702c7bb67b`: feste Linux-x86-64-Unitexe einmal +auf die Cloud-Linux-VM übertragen, vollständige Testliste ohne Filter geprüft, +danach genau ein Lauf als UID/GID65534 mit geleerten Zusatzgruppen und +`no-new-privs`. Kein RMM-Agent läuft auf dem Notebook. Der Prozess verwendete +keine RMM-IPC-, Approval-, Dienststeuerungs- oder Applyroute. + +**8 bestanden,0 fehlgeschlagen,0 ignoriert,0 gefiltert.** Erfasst sind: + +- geschlossene General/Full/Agent-Dienstmenge und Verweigerung eines APT-Restarts; +- kanonische Eventkette, feste Zeit-/Mengengrenzen und vollständiger16-Eventpfad; +- Erhaltung der Full-Rawbytes einschließlich des tatsächlich provisionierten + öffentlichen Filekeys ohne Einsetzen in das leere Inlinefeld; +- Verweigerung fremder Pins sowie unbekannter, doppelter oder escaped Felder; +- getrennte frische Healthsignatur, unverändertes `ready:false` und terminales Unknown; +- Besitz erst nach Stop, vollständiges Dateipaar und Rückgabe vor Restart. + +Vorher/nachher gleich: drei tatsächliche Agent-/General-/Full-Prozessgenerationen +mit PID, Prozessgeburt, Image und Konten; vier bekannte Config-/Pin-/Unitdateien +mit Rohhash und Metadaten; drei DB- und die vorhandene Executorlock-Dateiidentität; +Boot und weiterhin deaktivierter/inaktiver APT-Dienst. Ein separater rein +lesender Same-case-Aufruf bestätigte danach den gespeicherten Erfolg und +diesen aktuellen Zustand. Die Zielwirkung beschränkte sich auf den eigenen +Unitfall unter `/var/tmp/rmm-updater-handoff-` und den Testprozess. + +## Grenzen und nächste Arbeit + +Prozessgeburt/PID wurden beobachtet, kein durchgehender nativer Prozesshandle +gehalten. Die Erhaltung prüft bekannte Kontrollbytes und Dateiidentitäten, +keine vollständige SQL-/PKI-Historie. Lokale Belege flushen ihre Datei; +der bestehende lokale Transporthelper fsynct nicht zusätzlich das Elternverzeichnis. +Der exklusive Remote-Fall und Einmalmarker sperren normale Wiederholung. +Bei verlorenem Reply gilt ausschließlich Same-case-Readback, kein neuer Run. + +Dies ist ein nativer **Vertragskernnachweis**, kein Apply-, dauerhafter +SQLite-/Inflight-, IPC-, Dienststop-/Dateitausch-/Health-/Rollbacknachweis und +kein Windowsnachweis. Die tatsächliche Updateaction mit Katalog, Streaming, +MCP, fester WebUI-Genehmigung und unabhängiger Runtime wird parallel integriert. +Der bestehende Releaseverifier und seine ursprünglichen Native-Runner wurden +nicht verändert. Private Intents, Transportrückgaben und Originalausgaben +liegen gitignoriert unter `devstate/updater-handoff-native/03ddcaa5…/`. +Endbeleg-SHA256 `3a390ab47f63f2be58ab56728a7382909ae5249f5217d6f312455c4b497c64e3`, +separater Readback `388f86d5563cb53e48cd87a9a7c9ce10b02b695bfe195e574b769798fb960e66`. diff --git a/docs/handover.md b/docs/handover.md index bf178e3..e5e10ae 100644 --- a/docs/handover.md +++ b/docs/handover.md @@ -26,6 +26,12 @@ weiter0/0/0/0. Der parallele Linuxjob erklärt explizit31/31/27 statt30/30/26. [Tatsächlicher Beleg98f4edf](windows-clock-spnego-empty-trace.md). Der nächste isolierte Prozessprivilegvergleich ist noch kein Zielnachweis. +**Updater-Kernnachtrag:** Acht feste Handoff-/Fullrenderer-/Healthverträge aus +a2efb79 sind danach tatsächlich auf Cloud-Linux als UID65534 bestanden, +kein Skip/Filter; separates lesendes Readback und bekannte Dienst-/Kontroll-/ +Stateidentität erhalten. [Ergebnis und Grenzen](agent-updater-handoff-linux-results.md). +Keine Applyruntime oder Windowsqualifikation daraus ableiten. + **Vorheriger Betriebsstand der Skriptkonsole2026-11-14:** Cloudserver und WebUI sind im separaten Fall14dcc27d tatsächlich erhaltend bereitgestellt (ARM64-Image 6f8383f7, Migration14; alte Geschichte/Identitäten unverändert). Die drei neuen diff --git a/docs/parallel-mvp-status.md b/docs/parallel-mvp-status.md index 4f7dd20..9043a46 100644 --- a/docs/parallel-mvp-status.md +++ b/docs/parallel-mvp-status.md @@ -78,8 +78,11 @@ Readback, Cleanup und vollständige native RMM-Erhaltung bestanden; Windows weiter0/0/0/0. Die parallel genehmigte Linuxänderung ist ausdrücklich erfasst. [Beleg98f4edf und Grenzen](windows-clock-spnego-empty-trace.md). Ein separater Prozessprivilegvergleich wird vorbereitet, noch nicht nativ -ausgeführt. Updater-Handoffkernel inzwischen nach unabhängigem Review als -isolierter Quellschritt a2efb79 gepusht; Runtimeintegration läuft getrennt. +ausgeführt. Updater-Handoffkernel nach unabhängigem Review als isolierter +Quellschritt a2efb79 gepusht und anschließend **Cloud-Linux8 nativ bestanden**, +keine Skips/Filter, separater Readback und bekannte Dienst-/Kontroll-/ +Stateidentität erhalten. [Ergebnis](agent-updater-handoff-linux-results.md). +Runtimeintegration läuft getrennt; weder Apply noch Windows dadurch abgenommen. ## Fortschreibung: reale Quellenprüfungen und Bereitstellungsgrenzen