From 4b3cb5af77b3784106fe3386baa080687c492141 Mon Sep 17 00:00:00 2001 From: Kevin Janssen Date: Sun, 15 Nov 2026 09:21:24 +0100 Subject: [PATCH] Record isolated probe failures and first stopped fixture cleanup --- deploy/server_time_source_probe_acceptance.py | 255 ++++++++++++++++++ docs/server-time-source-probe-acceptance.md | 142 ++++++++++ docs/windows-raw-capture-completion.md | 13 + 3 files changed, 410 insertions(+) create mode 100644 deploy/server_time_source_probe_acceptance.py create mode 100644 docs/server-time-source-probe-acceptance.md diff --git a/deploy/server_time_source_probe_acceptance.py b/deploy/server_time_source_probe_acceptance.py new file mode 100644 index 0000000..c2f5ada --- /dev/null +++ b/deploy/server_time_source_probe_acceptance.py @@ -0,0 +1,255 @@ +#!/usr/bin/env python3 +"""One fixed source-quality acceptance after the original pre-exec GROUP failure. + +No transport, provisioning, original-phase retry, keys or broker installation. +Run only as the root operator with python3 -I; uncertain execution is read only. +""" +import argparse +import grp +import hashlib +import importlib.util +import json +import os +from pathlib import Path +import stat +import sys +import uuid + +CASE = '5b358997-3abc-43db-945f-f41855b4e3c0' +PHASE = 'probe-group-acceptance-v1' +PROFILE = 'rmm.server-time-source.group-acceptance.v1' +PIN_CONTROLLER_SHA = 'fac85dd0399009af36f625232daa5b67ab7fda391dbf95229d4237c307b142ca' +PIN_CONTROLLER = Path('/var/lib/rmm-time-source-operators') / PIN_CONTROLLER_SHA / 'pin_bootstrap.py' +PIN_RESULT_SHA = 'd0a9ac7b46bdf4247c420f01d959c41d6620f7081c40629016d6866828884c4b' +PUBLIC_PIN_SHA = '203f63f150026d345614ca53e641f248397166fbdeb1f28318fc5d7763317e0a' +GROUP_RECEIPT_SHA = '4977876b935bed8903ce4c880a0d9c77c49cd2c7110551fbf854baeccbe64ea7' +ARTIFACT = dict(bytes=848632, sha256='216b4d6a0f29ef47576f5ccc469954623141e55d7b43bd73175c1d956363bbbd', elf_machine=183) +BASE = Path('/var/lib/rmm-time-source-bootstrap') / CASE +IMAGE = BASE / 'build/artifacts/operator_probe' +OLD_UNIT = 'rmm-time-source-probe-' + CASE + '.service' +UNIT = 'rmm-time-source-probe-group-acceptance-' + CASE + '.service' +SAMPLE_KEYS = {'profile', 'clock_authority', 'signed_attestation', 'captured_utc_ns', + 'server_error_ns', 'source_sync_age_ns', 'server_boot_id', + 'captured_monotonic_ns', 'sampled_boottime_ns', 'kernel_state'} + + +def require(ok, reason): + if not ok: + raise RuntimeError(reason) + + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + + +def load_pin_controller(): + # Bootstrap the already reviewed reader without following import paths or + # executing a second, unchecked pathname read. All ancestors stay root-only writable. + parent = os.open('/', os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW) + try: + for part in PIN_CONTROLLER.parent.parts[1:]: + info = os.fstat(parent) + require(info.st_uid == 0 and info.st_mode & 0o022 == 0, 'protected_controller_ancestry') + child = os.open(part, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW, dir_fd=parent) + os.close(parent) + parent = child + info = os.fstat(parent) + require(info.st_uid == 0 and info.st_mode & 0o022 == 0, 'protected_controller_directory') + fd = os.open(PIN_CONTROLLER.name, os.O_RDONLY | os.O_NOFOLLOW, dir_fd=parent) + with os.fdopen(fd, 'rb') as stream: + before = os.fstat(stream.fileno()) + require(stat.S_ISREG(before.st_mode) and before.st_uid == before.st_gid == 0 and + before.st_nlink == 1 and stat.S_IMODE(before.st_mode) == 0o600 and + before.st_size <= 128 * 1024, 'fixed_root_controller_file') + raw = stream.read(128 * 1024 + 1) + stable = lambda item: tuple(getattr(item, 'st_' + key) for key in + ('dev', 'ino', 'uid', 'gid', 'mode', 'nlink', 'size', 'mtime_ns', 'ctime_ns')) + require(stable(before) == stable(os.fstat(stream.fileno())) == + stable(os.stat(PIN_CONTROLLER.name, dir_fd=parent, follow_symlinks=False)) and + len(raw) == before.st_size and + sha(raw) == PIN_CONTROLLER_SHA, 'exact_reviewed_pin_controller') + finally: + os.close(parent) + module = importlib.util.module_from_spec(importlib.util.spec_from_loader('rmm_fixed_pin_reader', loader=None)) + module.__file__ = str(PIN_CONTROLLER) + exec(compile(raw, str(PIN_CONTROLLER), 'exec'), module.__dict__) + held = module.read_file(PIN_CONTROLLER, 128 * 1024) + require(held[0] == raw, 'same_loaded_controller_bytes') + return module, lambda: require(module.read_file(PIN_CONTROLLER, 128 * 1024) == held, + 'pin_controller_unchanged') + + +def group_before_exec(old, log, rows, groups): + require(type(old.get('exit_code')) is int and old['exit_code'] == 216 and log == b'' and + old.get('sample') is None, 'original_216_empty_log_no_sample') + require(groups == [{'gid': 989, 'name': '_chrony', 'present': True}, + {'gid': 10001, 'present': False}], 'actual_original_nss_group_condition') + messages = [row.get('MESSAGE') for row in rows] + require(any(type(text) is str and 'Failed to determine supplementary groups' in text for text in messages) + and any(type(text) is str and 'Failed at step GROUP spawning ' + str(IMAGE) in text for text in messages) + and any(str(row.get('EXIT_STATUS')) == '216' and row.get('EXIT_CODE') == 'exited' for row in rows), + 'original_unit_journal_confirms_pre_exec_group_failure') + + +def sample_quality(sample, boot): + require(type(sample) is dict and set(sample) == SAMPLE_KEYS and + sample['profile'] == 'rmm.native-source-quality.once.v1' and + sample['clock_authority'] is False and sample['signed_attestation'] is False and + sample['server_boot_id'] == boot and str(uuid.UUID(boot)) == boot, + 'exact_non_authoritative_native_sample_schema_and_boot') + for key, upper in (('captured_utc_ns', 2**63 - 1), ('server_error_ns', 500_000_000), + ('source_sync_age_ns', 3_600_000_000_000), ('captured_monotonic_ns', 2**64 - 1), + ('sampled_boottime_ns', 2**64 - 1), ('kernel_state', 4)): + require(type(sample[key]) is int and 0 <= sample[key] <= upper, 'bounded_numeric_quality_sample') + require(sample['captured_utc_ns'] > 0 and sample['captured_monotonic_ns'] > 0 and + sample['sampled_boottime_ns'] >= sample['captured_monotonic_ns'], 'positive_native_time_domains') + + +def probe_args(): + return ['systemd-run', '--quiet', '--wait', '--pipe', '--collect', '--unit=' + UNIT, + '--property=Type=exec', '--property=User=root', '--property=Group=989', + '--property=SupplementaryGroups=', '--property=NoNewPrivileges=yes', + '--property=CapabilityBoundingSet=CAP_SYS_PTRACE', '--property=AmbientCapabilities=', + '--property=ProtectSystem=strict', '--property=ProtectHome=yes', '--property=PrivateTmp=yes', + '--property=PrivateDevices=yes', '--property=RestrictAddressFamilies=AF_UNIX', + '--property=IPAddressDeny=any', + '--property=SystemCallFilter=~@debug ptrace process_vm_readv process_vm_writev', + '--property=RuntimeMaxSec=3s', '--property=ReadWritePaths=/run/rmm-time-source/clients', str(IMAGE)] + + +def host_read(pin): + # No operator import, subprocess, NSS lookup, sockets, preflight or sample. + records = {} + for leaf in ('intent.json', 'before.json', 'group-before-exec.json', 'execution.json', + 'after.json', 'result.json', 'failure.json', 'probe.log'): + try: + raw, proof = pin.read_file(BASE / PHASE / leaf, 16384) + records[leaf] = {'sha256': sha(raw), 'metadata': proof, + 'record': raw.decode('ascii') if leaf == 'probe.log' else pin.parsed(raw)} + except FileNotFoundError: + records[leaf] = None + print(pin.encoded(dict(original_case=CASE, phase=PHASE, read_only=True, records=records)).decode('ascii'), end='') + + +def host_probe(pin, pin_guard): + case_fd = pin.directory(BASE) + phase_fd = -1 + try: + pin.absence(case_fd, PHASE) + operator, operator_guard = pin.load_operator() + original = pin.Original(BASE, operator, operator_guard) + require(original.artifacts['examples/operator_probe'][:2] == (IMAGE, ARTIFACT), 'fixed_original_native_artifact') + pin_raw, pin_proof = pin.read_file(BASE / 'pin/result.json') + require(sha(pin_raw) == PIN_RESULT_SHA, 'actual_original_pin_result') + pin_result = pin.parsed(pin_raw) + old_raw, old_proof = pin.read_file(BASE / 'probe/result.json') + old_log, old_log_proof = pin.read_file(BASE / 'probe/probe.log', 16384) + old = pin.parsed(old_raw) + require(old.get('artifact') == ARTIFACT and old.get('probe_log_sha256') == sha(old_log), + 'original_failed_probe_artifact_and_log') + + def fresh(): + pin_guard() + actual_pin = original.fresh() + require(pin.read_file(BASE / 'pin/result.json') == (pin_raw, pin_proof) and + pin.read_file(BASE / 'probe/result.json') == (old_raw, old_proof) and + pin.read_file(BASE / 'probe/probe.log', 16384) == (old_log, old_log_proof), + 'original_pin_and_failed_probe_records_unchanged') + raw, proof = pin.read_file(pin.ETC / 'chrony-pin.json', 8192) + require(sha(raw) == PUBLIC_PIN_SHA == pin_result['public_pin_sha256'] and + raw == pin.encoded(actual_pin) and proof == pin_result['public_pin_metadata'], + 'actual_unchanged_public_pin_and_original_metadata') + dirs = {} + for path in (pin.ETC, pin.RUN, pin.RUN / 'clients'): + fd = pin.directory(path) + try: + current = pin.stable_directory(os.fstat(fd)) + finally: + os.close(fd) + recorded = pin_result['targets'][str(path)] + require(current == {key: recorded[key] for key in current}, 'original_runtime_directory_identity') + dirs[str(path)] = current + return dict(observation=original.expected, public_pin_sha256=PUBLIC_PIN_SHA, + public_pin_metadata=proof, target_directories=dirs) + + before = fresh() + os.mkdir(PHASE, mode=0o700, dir_fd=case_fd) + os.fsync(case_fd) + phase_fd = os.open(PHASE, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW, dir_fd=case_fd) + own_raw, _ = pin.read_file(Path(__file__).absolute(), 128 * 1024) + binding = dict(profile=PROFILE, original_case=CASE, phase=PHASE, unit=UNIT, + controller_sha256=sha(own_raw), operator_sha256=pin.OPERATOR_SHA, + pin_controller_sha256=PIN_CONTROLLER_SHA, public_pin_sha256=PUBLIC_PIN_SHA, + source_tar_sha256=original.source_sha, manifest_sha256=original.manifest_sha, + artifact=ARTIFACT, original_group_receipt_sha256=GROUP_RECEIPT_SHA, + original_probe_result_sha256=sha(old_raw), pin_result_sha256=PIN_RESULT_SHA) + pin.exclusive(phase_fd, 'intent.json', pin.encoded(dict(binding, once=True, no_retry=True))) + groups = [] + for gid in (989, 10001): + try: + group = grp.getgrgid(gid) + groups.append(dict(gid=gid, name=group.gr_name, present=True)) + except KeyError: + groups.append(dict(gid=gid, present=False)) + boot = original.expected['boot_id'] + rows_raw = operator.run(['journalctl', '--unit=' + OLD_UNIT, '--boot=' + uuid.UUID(boot).hex, + '--no-pager', '-n', '12', '-o', 'json'], timeout=10, limit=65536) + rows = [pin.parsed(row) for row in rows_raw.splitlines()] + group_before_exec(old, old_log, rows, groups) + pin.exclusive(phase_fd, 'group-before-exec.json', pin.encoded(dict( + unit=OLD_UNIT, boot_id=boot, original_receipt_sha256=GROUP_RECEIPT_SHA, + original_probe_result_sha256=sha(old_raw), group_resolution=groups, + journal_sha256=sha(rows_raw), pre_exec_group_failure=True))) + pin.exclusive(phase_fd, 'before.json', pin.encoded(dict(binding, witness=before))) + fresh() # Last source/runtime/pin guard before the single executable action. + code = operator.long_command(probe_args(), BASE / PHASE / 'probe.log', 10) + log_raw, _ = pin.read_file(BASE / PHASE / 'probe.log', 16384) + execution = dict(binding, exit_code=code, probe_log_sha256=sha(log_raw)) + pin.exclusive(phase_fd, 'execution.json', pin.encoded(execution)) + after = fresh() + require(before == after, 'all_original_runtime_boot_pin_source_witnesses_preserved') + pin.exclusive(phase_fd, 'after.json', pin.encoded(dict(binding, witness=after))) + sample = pin.parsed(log_raw) if code == 0 else None + if code == 0: + sample_quality(sample, boot) + links = {} + for name in ('before', 'after'): + raw, _ = pin.read_file(BASE / PHASE / (name + '.json'), 16384) + links[name + '_witness'] = dict(filename=name + '.json', sha256=sha(raw)) + result = dict(binding, **links, exit_code=code, sample=sample, probe_log_sha256=sha(log_raw), + source_quality_qualified=code == 0, runtime_boot_pin_source_preserved=True, + clock_authority=False, signed_attestation=False, signer_created=False, + broker_started=False, http_deployed=False) + pin.exclusive(phase_fd, 'result.json', pin.encoded(result)) + print(pin.encoded(result).decode('ascii'), end='') + except Exception as error: + if phase_fd >= 0: + pin.exclusive(phase_fd, 'failure.json', pin.encoded(dict(profile=PROFILE, original_case=CASE, + failed=True, exception_type=type(error).__name__, read_original_phase_only=True))) + raise + finally: + if phase_fd >= 0: + os.close(phase_fd) + os.close(case_fd) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('command', choices=('host-probe', 'host-read')) + args = parser.parse_args() + require(sys.flags.isolated == 1 and os.geteuid() == 0 and os.uname().sysname == 'Linux' and + os.uname().machine == 'aarch64', 'isolated_root_linux_aarch64_only') + os.umask(0o077) + pin, guard = load_pin_controller() + if args.command == 'host-read': + host_read(pin) + else: + host_probe(pin, guard) + + +if __name__ == '__main__': + try: + main() + except Exception: + print(json.dumps(dict(failed=True, read_original_phase_only=True)), flush=True) + raise SystemExit(1) diff --git a/docs/server-time-source-probe-acceptance.md b/docs/server-time-source-probe-acceptance.md new file mode 100644 index 0000000..2a19491 --- /dev/null +++ b/docs/server-time-source-probe-acceptance.md @@ -0,0 +1,142 @@ +# Einmalige Qualitätsprobe nach dem nachgewiesenen GROUP-VorExecfehler + +`deploy/server_time_source_probe_acceptance.py` ist ein neuer enger Rootoperator +für genau den ursprünglichen ARM64-Fall +`5b358997-3abc-43db-945f-f41855b4e3c0`. Er wiederholt oder überschreibt nicht +dessen alte `probe`-Phase. Der tatsächliche rein lesende Journal-/NSS-Befund +f5ca944a, SHA256 +`4977876b935bed8903ce4c880a0d9c77c49cd2c7110551fbf854baeccbe64ea7`, +belegt `216/GROUP` und „Failed to determine supplementary groups“ vor ELFexec. +989 ist `_chrony`; 10001 fehlt. Das alte Ergebnis216 und das leere alte Log +bleiben unverändert erhalten. Dies ist kein nachträglicher Erfolg dieser Probe. + +Der neue Operator hat keine SSH-Funktion und akzeptiert keine frei wählbaren +Cases, Dateien, Hashes oder Programmargumente. Er lädt ausschließlich die +geprüften gehaltenen Root600-Bytes des Pincontrollersfac85dd0 unter +`/var/lib/rmm-time-source-operators/fac85dd0399009af36f625232daa5b67ab7fda391dbf95229d4237c307b142ca/pin_bootstrap.py`. +Dessen geschützter Import des Originaloperatorsecb72b7c und vollständige +Original-/Source-/Artefakt-/Chrony-/Boot-/Runtimeguards bleiben Pflicht. + +Verbindliches ELF ist die ursprüngliche Root500-/Singlelink-Providerprobe: +848632Bytes, ELF64/AArch64-Machine183, SHA256 +`216b4d6a0f29ef47576f5ccc469954623141e55d7b43bd73175c1d956363bbbd`. +Der originale Pinresult-SHA256d0a9ac7b und der öffentliche Pin +`203f63f150026d345614ca53e641f248397166fbdeb1f28318fc5d7763317e0a` +werden unabhängig nachgelesen. Der aktuelle Pin muss exakt zur frischen +Originalprojektion passen; Identität/Owner/Modus und Quelldaten bleiben erhalten. +Die bestehende Chronyprojektion schließt ausschließlich ihre bereits reviewten +inzidentellen Daemonverzeichnis-Zeitstempel aus. Für die eigenen Runtime- +verzeichnisse werden Dev/Inode/UID/GID/Modus verglichen; Eintragsgrößen und +Zeitstempel sind kein zusätzlicher Identitätsbeweis. Der vollständige originale +Pinresult bleibt daneben auf exakte Bytes und Metadaten gebunden. + +## Eigene endliche Phase + +Ein tatsächlicher Aufruf kann ausschließlich einmal die neue Phase +`/var/lib/rmm-time-source-bootstrap/5b358997-3abc-43db-945f-f41855b4e3c0/probe-group-acceptance-v1` +erzeugen. Vor Probeexec liegt ein eigener create-only/fsync-Intent vor. Danach +werden der alte GROUP-VorExecbefund im begrenzten Journal genau der Originalunit +und desselben Boots sowie die NSS-Gruppenbedingung erneut ausschließlich lesend +geprüft. Die Probe muss **vor** einer später separat genehmigten Anlage von +Gruppe10001 erfolgen; vorhandene10001 wird nicht adoptiert oder verändert. + +Genau eine neue demandgestartete Unit +`rmm-time-source-probe-group-acceptance-5b358997-3abc-43db-945f-f41855b4e3c0.service` +führt das unveränderte ELF aus. Gegenüber dem ursprünglichen Probeprofil ist +ausschließlich die unnötige Zusatzgruppe entfernt (`SupplementaryGroups=`). +Root/primäreGruppe989, NoNewPrivileges, CapabilityBoundingSet nurCAP_SYS_PTRACE, +ProtectSystem=strict, ProtectHome, PrivateTmp/Devices, AF_UNIX-only, IP-deny, +Debug-/ptrace-/process_vm-Syscalldeny, RuntimeMaxSec3s, äußerer10s-Wächter und +Schreiben ausschließlich im vorhandenen eigenen Chrony-Clientverzeichnis bleiben. +Keine Gruppenanlage, chmod, NTP-/Clocksetter, Schlüssel, Signatur, Broker-/RMM- +Dienständerung oder Jobwirkung. Jeder RMM-Job bleibt WebUI-genehmigungspflichtig. + +Rohlog und tatsächlicher Exit werden vor abschließenden Erhaltungsprüfungen als +eigene Ausführungsbelege gesichert. `before.json`/`after.json` enthalten vollständige +frische Originalprojektion, Pinmetadaten und Verzeichnisidentitäten; das Ergebnis +bindet beide Dateien per Name/SHA. Quelle, Artefakte, originale Phasen/fehlgeschlagene +Probe, Pin und tatsächlicher Laufzeitbestand werden vor/nach der einen Probe +erneut geprüft. Fehler oder Antwortverlust erlauben ausschließlich Lesen dieser +Phase; keine automatische Wiederholung, neuer Case oder generische Resumefunktion. + +## Ergebnisvertrag und geplante Bedienung + +Nur nach Exit0, erhaltenen Originalzeugen und streng validiertem Ausgabeobjekt +enthält `result.json` `source_quality_qualified=true`. Der genaue Samplevertrag +ist das unveränderte `operator_probe`-JSON: eigene Boot-ID muss dem Originalboot +entsprechen; UTC/Monotonic/Boottime sind echte begrenzte Integer, Gesamtfehler +höchstens500ms, Quellalter höchstens1h und Kernelstate0..4 gemäß geprüftem Provider. +Unbekannte/fehlende Felder, bool statt Zahl und abweichender Boot verweigern. +`clock_authority=false` und `signed_attestation=false` bleiben fest. Ein Exit +ungleich0 bleibt mit wirklichem Exit und `sample=null` unqualifiziert erhalten. + +Resultbinding: `profile`, `original_case`, `phase`, `unit`, `controller_sha256`, +`operator_sha256`, `pin_controller_sha256`, `public_pin_sha256`, +`source_tar_sha256`, `manifest_sha256`, `artifact`, +`original_group_receipt_sha256`, `original_probe_result_sha256`, `pin_result_sha256`. +`before_witness`/`after_witness` sind jeweils `{filename,sha256}` mit festen +`before.json`/`after.json`; diese enthalten dasselbe Binding plus `witness`. +Weitere Ergebnisfelder sind `exit_code`, `sample`, `probe_log_sha256`, +`source_quality_qualified`, `runtime_boot_pin_source_preserved`, +`clock_authority`, `signed_attestation`, `signer_created`, `broker_started`, +`http_deployed`. Diese Probe aktiviert weder Windowsclock noch Jobgate. + +Geplant, **nicht durch diese Implementierungsarbeit ausgeführt**: + +```text +python3 -I /reviewter/geschuetzter/pfad/probe_acceptance.py host-probe +python3 -I /reviewter/geschuetzter/pfad/probe_acceptance.py host-read +``` + +`host-read` liest ausschließlich vorhandene begrenzte Phasenrecords und Log; +kein subprocess, NSS, Preflight, Socketaufruf oder erneutes Sampling. +Roottransport/Quellhashreview und die tatsächliche native Ausführung bleiben +beim Rootoperator. Dieser Schnitt behauptet keinen nativen Qualitätsnachweis. + +## Tatsächlich lokal geprüft + +Source-SHA256 +`d04989ccf6d3e7b379a1b02f5fd3ce2545a3563fbce1368f33102f58a36f2dcf`. +Im privaten Fall `847bfdf0-ea79-44b2-b0ef-5f1193c95e49` bestanden Python-AST +und zwei reine lokale Fixturefälle: der tatsächliche gespeicherte GROUPbefund +wurde als positive Eingabe verwendet; Exit0, nichtleeres Altlog, fehlende +Journalbelege und bereits vorhandene10001 wurden verweigert. Die zweite +Fixture verglich alle systemd-Argumente unmittelbar gegen den fest gehashten +Originaloperator: ausschließlich eigene Unit und leere Zusatzgruppen ändern +sich. Strikte numerische Qualitäts-/Boot-/Schemasperren bestanden ebenfalls. +Receipt-SHA256 +`0ffa57a2ac522794e81784360a9e9af570a861bffb31df3033192c50f03d3e53`. +Die Receipt bindet die davor vorhandene Dokumentfassung; dieser Ergebnisnachtrag +ändert weder Source noch die tatsächlich geprüften Argumente. Die Fixtures +rufen weder systemd/Docker noch NSS, Journal oder Clockgetter auf; keine +Zielaktion wurde ausgeführt. Native Ausführung bleibt offen. + +## Tatsächliche Ausführung und geschlossene Qualitätsgrenze + +2026-11-15: Originalprobe im Buildfall5b358997 endete vor Exec mit216/GROUP. +Die rein lesende Originalunit-Journalabfrage bestätigt fehlgeschlagene +Supplementarygroup-Auflösung10001;989/_chrony existiert. Receipt +`4977876b935bed8903ce4c880a0d9c77c49cd2c7110551fbf854baeccbe64ea7`. +Die getrennte neue Phaseprobe-group-acceptance-v1 mit Controllerd04989cc +wurde anschließend genau einmal ausgeführt, ohne unnötige Zusatzgruppe. +Das Programm wurde diesmal gestartet, endete aber mit1 und festem +TIME_SOURCE_OPERATOR_PROBE_DENIED. Keine Sample-/Qualitätsqualifikation. +Ausführungsreceipt +`6923cc1893619f67ae8677b84f9cfea6d0edd554120e9139d843115e52aa7643`, +Log-SHA256 +`f80644630b09f50fdc731418dbe4f17fff32622910b3efd346a0369b75e985ef`. +Originalphase und ihr fehlgeschlagenes Resultat bleiben unverändert. + +Eine getrennte tatsächlich rein lesende DAC-Diagnose erfasste zwei eigene +Rootprozesse mit EGID989/keinen Zusatzgruppen: CAP_SYS_PTRACE allein +(CapEff0x80000) verweigert Öffnen des Chrony0700-Verzeichnisses und bloßes +Unixdatagramm-Connect zum Socket0755 mit EACCES13. Mit zusätzlich +CAP_DAC_OVERRIDE (CapEff0x80002) gelangen beide. Kein Datagramm gesendet, +keine Datei angelegt, kein Zeitsetter, keine Änderung an Chrony-ACLs. Receipt +`d999e5260cab3457a7a66603fdb0288615443628e5a28f31df9c1cecd3401ef5`. +Die bisherige Rootdienst-Capabilitybegrenzung reicht folglich für diese +tatsächliche vorhandene Quellkonfiguration nicht. Eine folgende eigene +Probephase benötigt diese dokumentierte zusätzliche Zugriffscapability; +Root-ROFS, AF_UNIX-only/IPdeny, Pfad-/Inode-/Owner-/SCM-Credentialprüfungen +und Verbot von CAP_SYS_TIME bleiben erhalten. Es wurde noch kein +erfolgreiches natives Qualitätssample oder signierter Vergleich gemessen. diff --git a/docs/windows-raw-capture-completion.md b/docs/windows-raw-capture-completion.md index 429948e..aef88a8 100644 --- a/docs/windows-raw-capture-completion.md +++ b/docs/windows-raw-capture-completion.md @@ -219,3 +219,16 @@ Report-/End-/Exitbelegen und unveränderten RMM-/Journal-/Serverzeugen. Keine RMM-Jobs, Uhrstellung, W32Time-Anweisung oder Clockgateöffnung. Die anschließend getrennte gestoppte Bereinigung sowie echte signierte Agent-/SYSTEM-Vergleiche und Deadlineintegration bleiben offen. + +## Erste getrennte Fixturebereinigung + +2026-11-15: Nach positiven beiden Rollen ausschließlich den exakt +verifizierten gestoppten LocalService-Messdienst einmal gelöscht, tatsächliche +SCM-Abwesenheit beobachtet. Receipt +`7d2e86a47abeac40829c0cec894480a8e8641770787ac05f26fc19db12d0ef72`. +Separater Originalread02f2f031-31b7-4283-af16-a84cd864a34d bestätigt +Abwesenheit und beide ursprünglichen Rollen-/Exitbelege, Receipt +`03b584dab2aac890e118e53a1b7435c64e4cc26ce65bb65a609b775da4a72575`. +RMM-/Serverzeugen unverändert. Der eigene SYSTEM-Messdienst bleibt bis zum +eigenen Cleanup gestoppt. Dateien/Reports bleiben unverändert erhalten; +kein RMM-Dienst oder Client wurde deinstalliert.