diff --git a/deploy/updater_linux_reopen_acceptance.py b/deploy/updater_linux_reopen_acceptance.py new file mode 100644 index 0000000..50552a0 --- /dev/null +++ b/deploy/updater_linux_reopen_acceptance.py @@ -0,0 +1,314 @@ +#!/usr/bin/env python3 +"""Frozen six Linux OS-port units only; no updater service or Apply. + +Prepare copies the independently reviewed snapshot locally. Execute is one +root-only Cloud-VM fixture run. After any lost reply read the original case; +never execute it again or substitute another binary/source generation. +""" +import argparse +import base64 +import hashlib +import inspect +import json +import os +from pathlib import Path +import stat +import uuid + +import windows_msi_runtime_acceptance as support + +ROOT = Path(__file__).resolve().parents[1] +UPDATER = ROOT.parent / 'rust-discovery-agent-updater' +QUALIFICATION = UPDATER / 'devstate/agent-updater-linux/qualification-os6-0b3c8018-b08f-4917-80b8-0e3169a0f813' +STATE = ROOT / 'devstate/updater-linux-native-reopen' +PROFILE = 'rmm.updater-linux.six-os-units.v1' +RECEIPT_SHA = 'c3e1ee619ef01630b296aaf7669d04f39ea952b1ec2d7adc1a791f69f6a6ee08' +INPUTS_SHA = '4f92d291e9edb63198f77071f73fe447f6cca0b040290e93b75673212ff4dd67' +BINARY_SHA = 'c78d24d9b3f543fc4eba3fa1d02bf82e72aea26493ae689f2fc82ee1067d33fc' +BINARY_BYTES = 1555392 +TESTS = sorted('''files::reopen_tests::bound_reopen_rejects_same_byte_name_substitution_and_added_stage_hardlink +ipc::tests::framing_denies_large_duplicate_unknown_and_unbound_requests_before_dispatch +ipc::tests::partial_socket_frame_does_not_extend_its_total_deadline +tests::held_file_rejects_symlink_and_replaced_name_but_preserves_bound_hardlinks +tests::pidfd_image_birth_account_and_exit_are_independently_observed +tests::same_pid_exec_rejects_changed_image_despite_retained_pidfd_birth_and_credentials'''.splitlines()) +AGENT_SHA = '0a7ad6eefaefda79ee80b6a41b2df904e9e7f50ae6ebeed01b98c25b6ce5c06f' +HELPER_SHA = '79442727c3ba31cda02a8bc0e67481f14db9f39fc07520a880a90b64f10f1eaf' + + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + + +def save_local(path, value): + support.save(path, value) + fd = os.open(path.parent, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW) + try: + os.fsync(fd) + finally: + os.close(fd) + + +def copy_exact(source, destination, digest, size): + metadata = source.lstat() + support.require(stat.S_ISREG(metadata.st_mode) and metadata.st_nlink == 1 + and metadata.st_uid in (0, os.getuid()) and not metadata.st_mode & 0o002 + and metadata.st_size == size and size <= 2 * 1024 * 1024, 'bounded regular frozen input') + raw = source.read_bytes() + support.require(sha(raw) == digest, 'frozen snapshot input hash') + destination.parent.mkdir(mode=0o700, parents=True, exist_ok=True) + support.private(destination.parent, True) + fd = os.open(destination, os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW | os.O_WRONLY, 0o600) + with os.fdopen(fd, 'wb') as stream: + stream.write(raw); stream.flush(); os.fsync(stream.fileno()) + fd = os.open(destination.parent, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW) + try: + os.fsync(fd) + finally: + os.close(fd) + + +def verify_case(folder): + value = support.load(folder / 'manifest.json') + support.require(value['profile'] == PROFILE and value['tests'] == TESTS + and value['runner_sha256'] == sha(Path(__file__).read_bytes()) + and value['receipt_sha256'] == RECEIPT_SHA and value['binary_sha256'] == BINARY_SHA + and value['binary_bytes'] == BINARY_BYTES, 'same original reviewed manifest') + support.require(sha((folder / 'receipt.json').read_bytes()) == RECEIPT_SHA + and sha((folder / 'inputs.json').read_bytes()) == INPUTS_SHA, 'original qualification provenance') + source = support.load(folder / 'inputs.json') + support.require(len(source) == 23 and source == value['source_files'], 'exact frozen 23 inputs') + for item in source: + path = Path(item['path']) + support.require(not path.is_absolute() and '..' not in path.parts, 'fixed snapshot relative path') + file = folder / 'source' / path + support.private(file) + support.require(file.stat().st_size == item['bytes'] and sha(file.read_bytes()) == item['sha256'], 'retained source freeze') + binary = folder / 'os-port-tests'; support.private(binary) + support.require(binary.stat().st_size == BINARY_BYTES and sha(binary.read_bytes()) == BINARY_SHA, 'original qualified test bytes') + for path, digest in value['transport_sources'].items(): + support.require(sha((ROOT / path).read_bytes()) == digest, 'original strict transport source') + return value + + +def remote(p): + import base64 + import hashlib + import json + import os + from pathlib import Path + import selectors + import signal + import stat + import subprocess + import time + import uuid + + def require(ok, message): + if not ok: + raise RuntimeError(message) + + def enc(value): + return json.dumps(value, 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 stream: + stream.write(raw); stream.flush(); os.fsync(stream.fileno()) + fd = os.open(path.parent, os.O_DIRECTORY | os.O_RDONLY | os.O_NOFOLLOW) + try: + os.fsync(fd) + finally: + os.close(fd) + + def run(args, timeout=20): + # Keep the owned group leader unreaped until its entire group has been + # cleaned up. Its PID therefore cannot be recycled before killpg. + child = subprocess.Popen(args, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, + stderr=subprocess.PIPE, start_new_session=True, + env={'PATH': '/usr/bin:/bin', 'LC_ALL': 'C', 'HOME': '/nonexistent'}) + selector = selectors.DefaultSelector() + buffers = {'stdout': bytearray(), 'stderr': bytearray()} + deadline = time.monotonic() + timeout + try: + for stream, name in ((child.stdout, 'stdout'), (child.stderr, 'stderr')): + os.set_blocking(stream.fileno(), False); selector.register(stream, selectors.EVENT_READ, name) + while True: + require(time.monotonic() < deadline, 'owned native command timeout; read original case only') + for key, _ in selector.select(0.02): + raw = os.read(key.fileobj.fileno(), 4096) + if raw: + buffers[key.data].extend(raw) + require(len(buffers[key.data]) <= 65536, 'bounded native output') + else: + selector.unregister(key.fileobj) + ended = os.waitid(os.P_PID, child.pid, os.WEXITED | os.WNOHANG | os.WNOWAIT) + if ended is not None: + # Child remains a zombie until finally: no PID/group reuse. + os.killpg(child.pid, signal.SIGKILL) + for key in list(selector.get_map().values()): + while True: + try: + raw = os.read(key.fileobj.fileno(), 4096) + except BlockingIOError: + break + if not raw: + break + buffers[key.data].extend(raw) + require(len(buffers[key.data]) <= 65536, 'bounded native output') + code = ended.si_status if ended.si_code == os.CLD_EXITED else -ended.si_status + return code, bytes(buffers['stdout']), bytes(buffers['stderr']) + finally: + os.killpg(child.pid, signal.SIGKILL) + child.wait() + selector.close(); child.stdout.close(); child.stderr.close() + + def metadata_identity(value): + return (value.st_dev, value.st_ino, value.st_uid, value.st_gid, value.st_mode, + value.st_nlink, value.st_size, value.st_mtime_ns, value.st_ctime_ns) + + def hashed(path, maximum, process_image=False): + fd = os.open(path, os.O_RDONLY | os.O_CLOEXEC | (0 if process_image else os.O_NOFOLLOW)) + with os.fdopen(fd, 'rb') as stream: + before = os.fstat(stream.fileno()); require(stat.S_ISREG(before.st_mode) and before.st_size <= maximum, 'bounded witness file') + digest = hashlib.sha256(); total = 0 + while True: + raw = stream.read(32768) + if not raw: + break + total += len(raw); require(total <= maximum, 'bounded witness hash'); digest.update(raw) + after = os.fstat(stream.fileno()) + require(metadata_identity(before) == metadata_identity(after) and total == before.st_size, 'stable witness hash') + return before, digest.hexdigest() + + def witness(): + out = {'boot_id': Path('/proc/sys/kernel/random/boot_id').read_text().strip(), 'services': {}, 'files': {}} + release = dict(line.split('=', 1) for line in Path('/etc/os-release').read_text().splitlines() if '=' in line) + require(release.get('ID', '').strip('"') == 'ubuntu' and release.get('VERSION_ID', '').strip('"') == '24.04', 'fixed native Ubuntu24.04') + out['os'] = {'id': 'ubuntu', 'version': '24.04', 'machine': os.uname().machine, 'kernel': os.uname().release} + 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'])): + code, stdout, _ = run(['/usr/bin/systemctl', 'show', name, '-p', 'ActiveState', '-p', 'MainPID', '-p', 'UnitFileState', '-p', 'InvocationID']) + require(code == 0, 'existing service read') + service = dict(line.split('=', 1) for line in stdout.decode().splitlines()) + pid = int(service['MainPID']); require(service['ActiveState'] == 'active' and pid > 1, 'three existing services active') + proc = Path('/proc', str(pid)); birth = (proc / 'stat').read_text().rsplit(') ', 1)[1].split()[19] + ids = {line.split(':')[0]: line.split()[1:] for line in (proc / 'status').read_text().splitlines() if line.startswith(('Uid:', 'Gid:'))} + metadata, image = hashed(proc / 'exe', 256 * 1024 * 1024, process_image=True) + current = (proc / 'exe').stat() + require(ids['Uid'] == [str(uid)] * 4 and ids['Gid'] == ['984'] * 4 and image == binary + and (metadata.st_dev, metadata.st_ino) == (current.st_dev, current.st_ino) + and (proc / 'stat').read_text().rsplit(') ', 1)[1].split()[19] == birth, 'current generation/account/image') + out['services'][name] = dict(service, birth=birth, image=image, ids=ids) + code, stdout, _ = run(['/usr/bin/systemctl', 'show', 'rmm-apt-helper.service', '-p', 'ActiveState', '-p', 'UnitFileState']) + apt = dict(line.split('=', 1) for line in stdout.decode().splitlines()) + require(code == 0 and 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); metadata = path.lstat() + require(not path.is_symlink() and stat.S_ISREG(metadata.st_mode) and metadata.st_uid == 0 + and not metadata.st_mode & 0o022 and metadata.st_nlink == 1, 'protected known control') + current, digest = hashed(path, 65536) + require(metadata_identity(current) == metadata_identity(metadata), 'same known control file') + out['files'][name] = [metadata.st_dev, metadata.st_ino, metadata.st_uid, metadata.st_gid, metadata.st_mode, + metadata.st_size, metadata.st_mtime_ns, metadata.st_ctime_ns, digest] + 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); metadata = path.lstat() + require(not path.is_symlink() and stat.S_ISREG(metadata.st_mode) and metadata.st_nlink == 1, 'existing state identity') + out['files'][name] = [metadata.st_dev, metadata.st_ino, metadata.st_uid, metadata.st_gid, metadata.st_mode] + return out + + require(os.geteuid() == 0 and os.uname().machine == 'x86_64', 'fixed Cloud Linux root OS fixtures') + ident = str(uuid.UUID(p['id'])); require(ident == p['id'], 'canonical original case') + folder = Path('/var/tmp') / ('rmm-updater-linux-os6-' + ident) + if p['action'] == 'read': + metadata = folder.lstat() + require(stat.S_ISDIR(metadata.st_mode) and not folder.is_symlink() and metadata.st_uid == 0 + and stat.S_IMODE(metadata.st_mode) == 0o700, 'own original case only') + result = folder / 'result.json' + return {'read_only': True, 'id': ident, 'entered': (folder / 'entered.json').exists(), + 'result': json.loads(result.read_bytes()) if result.exists() else None, 'current_witness': witness()} + require(p['action'] == 'execute', 'one fixed OS unit action') + os.umask(0o077); folder.mkdir(mode=0o700) + create(folder / 'intent.json', enc({key: value for key, value in p.items() if key != 'binary_b64'})) + require(len(p['binary_b64']) == 2073856, 'bounded binary transfer') + raw = base64.b64decode(p['binary_b64'], validate=True) + require(len(raw) == 1555392 and hashlib.sha256(raw).hexdigest() == p['binary_sha256'], 'fixed six-unit binary') + binary = folder / 'os-port-tests'; create(binary, raw, 0o700) + before = witness(); create(folder / 'before.json', enc(before)) + command = ['/usr/bin/setpriv', '--reuid=0', '--regid=0', '--clear-groups', '--no-new-privs', str(binary)] + code, stdout, stderr = run(command + ['--list', '--format', 'terse']) + create(folder / 'list.stdout', stdout); create(folder / 'list.stderr', stderr) + require(code == 0 and stderr == b'', 'native list succeeded') + lines = stdout.decode().splitlines() + require(len(lines) == 6 and sorted(line[:-6] for line in lines if line.endswith(': test')) == p['tests'], 'exact six tests before any run') + create(folder / 'entered.json', enc({'id': ident, 'run_once': True, 'time_ns': time.time_ns()})) + code, stdout, stderr = run(command + ['--test-threads=1', '--nocapture']) + create(folder / 'run.stdout', stdout); create(folder / 'run.stderr', stderr) + after = witness(); create(folder / 'after.json', enc(after)) + require(before == after and code == 0 and stderr == b'' + and b'6 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out' in stdout + and all((b'test ' + name.encode() + b' ... ok') in stdout for name in p['tests']), 'six native units and retained target state') + receipt = dict(id=ident, profile=p['profile'], passed=6, ignored=0, filtered=0, execution_uid=0, tests=p['tests'], + before=before, after=after, binary_sha256=p['binary_sha256'], source_receipt_sha256=p['receipt_sha256'], + source_manifest_sha256=p['manifest_sha256'], stdout_sha256=hashlib.sha256(stdout).hexdigest(), + no_rmm_jobs=True, no_apply=True, no_service_control=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, parents=True, exist_ok=True); support.private(STATE, True) + if args.action == 'prepare': + support.require(args.case is None, 'prepare one new local case') + receipt_path = QUALIFICATION / 'receipt.json'; support.private(receipt_path) + support.require(sha(receipt_path.read_bytes()) == RECEIPT_SHA, 'independently reviewed source receipt') + receipt = support.load(receipt_path); original = support.load(QUALIFICATION / 'inputs.json') + support.require(sha((QUALIFICATION / 'inputs.json').read_bytes()) == INPUTS_SHA + and receipt['inputs_sha256'] == INPUTS_SHA and len(original) == 23 + and receipt['result'] == 'LOCAL_ONLY_OS6_PASS' and receipt['tests'] == 6 + and receipt['skips'] == 0 and receipt['filters'] == 0, 'reviewed six-test qualification') + ident = str(uuid.uuid4()); folder = STATE / ident; folder.mkdir(mode=0o700) + copy_exact(receipt_path, folder / 'receipt.json', RECEIPT_SHA, receipt_path.stat().st_size) + copy_exact(QUALIFICATION / 'inputs.json', folder / 'inputs.json', INPUTS_SHA, (QUALIFICATION / 'inputs.json').stat().st_size) + paths = set() + for item in original: + path = Path(item['path']) + support.require(not path.is_absolute() and '..' not in path.parts and str(path) not in paths, 'unique fixed frozen input') + paths.add(str(path)); copy_exact(QUALIFICATION / 'source' / path, folder / 'source' / path, item['sha256'], item['bytes']) + binary = QUALIFICATION / 'qualified-os6-tests' + support.require(receipt['artifacts'][0] == dict(path='qualified-os6-tests', bytes=BINARY_BYTES, sha256=BINARY_SHA), 'fixed original linked artifact') + copy_exact(binary, folder / 'os-port-tests', BINARY_SHA, BINARY_BYTES) + transports = {path: sha((ROOT / path).read_bytes()) for path in ('deploy/windows_msi_runtime_acceptance.py', 'deploy/vm_access_check.py')} + save_local(folder / 'manifest.json', dict(id=ident, profile=PROFILE, runner_sha256=sha(Path(__file__).read_bytes()), + receipt_sha256=RECEIPT_SHA, binary_sha256=BINARY_SHA, binary_bytes=BINARY_BYTES, + source_files=original, tests=TESTS, transport_sources=transports)) + verify_case(folder) + print(json.dumps({'id': ident, 'prepared_locally': True})); return + support.require(args.case is not None, 'original --case required') + ident = str(uuid.UUID(args.case)); support.require(ident == args.case, 'same canonical original case') + folder = STATE / ident; support.private(folder, True); verify_case(folder) + payload = dict(id=ident, action=args.action, profile=PROFILE, tests=TESTS, binary_sha256=BINARY_SHA, + receipt_sha256=RECEIPT_SHA, manifest_sha256=sha((folder / 'manifest.json').read_bytes()), + agent_sha256=AGENT_SHA, helper_sha256=HELPER_SHA) + if args.action == 'execute': + save_local(folder / 'execute-entered.json', {'once': True, 'no_retry': True}) + payload['binary_b64'] = base64.b64encode((folder / 'os-port-tests').read_bytes()).decode() + 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) + save_local(folder / (args.action + '-' + str(uuid.uuid4()) + '.json'), response) + if args.action == 'read' and response['result'] is not None: + support.require(response['result']['source_manifest_sha256'] == sha((folder / 'manifest.json').read_bytes()) + and response['current_witness'] == response['result']['after'], 'same-case retained native result') + print(json.dumps({'id': ident, 'action': args.action, 'passed': response.get('passed'), + 'complete': response.get('result') is not None if args.action == 'read' else True, 'read_only': args.action == 'read'})) + + +if __name__ == '__main__': + main() diff --git a/docs/agent-updater-linux-native-results.md b/docs/agent-updater-linux-native-results.md index 84a9317..48509ec 100644 --- a/docs/agent-updater-linux-native-results.md +++ b/docs/agent-updater-linux-native-results.md @@ -1,4 +1,4 @@ -# Linux-Updaterport: nativer Fünfertest bestanden +# Linux-Updaterport: native Fünfer- und Sechsertests bestanden 2026-11-14. Dieser Schritt prüft ausschließlich die fünf isolierten OS-Units des Linuxports. **Auf der Cloud-VM als UID0 bestanden:5/5, kein Skip/Filter.** Kein Apply-, Autoupdater- oder @@ -151,3 +151,56 @@ Checkpoint1e89c45 bytegleich erhalten. Von den22 eingefrorenen Eingaben stimmen spätere Plan-/Health-/Provisionierungsintegration erweitert. Der neue gesamte Workspace ist damit nicht pauschal nativ qualifiziert. Seine separaten lokalen Compiler-/Prüfbelege bleiben von diesem ursprünglichen Fünfertest getrennt. + + +## Neuer Sechsernachweis nach gebundenem Stage-Reopen + +Der getrennte Quellenstand328e440 (Mainmerge7d328ee) ergänzt das gebundene +Wiederöffnen eines bereits verifizierten Stagings. Der neue Runner +`deploy/updater_linux_reopen_acceptance.py`, SHA256 +`8a27924b829946e24e9870b9e6af71508dee6495ee7840c51f809cfecf94c10a`, +bindet23 eingefrorene Inputs und die neue Sechserexe:1555392Byte, SHA256 +`c78d24d9b3f543fc4eba3fa1d02bf82e72aea26493ae689f2fc82ee1067d33fc`. +Der lokale Qualifikationsreceipt hat SHA256 +`c3e1ee619ef01630b296aaf7669d04f39ea952b1ec2d7adc1a791f69f6a6ee08`. +Die sieben OSportquellen entsprechen diesem öffentlichen Stand; spätere +Worker-/Runtimeänderungen sind dadurch nicht qualifiziert. + +Die ursprünglichen fünf Namen bleiben enthalten. Hinzu kommt exakt +`files::reopen_tests::bound_reopen_rejects_same_byte_name_substitution_and_added_stage_hardlink`. +Die Probe verwendet ausschließlich ein eigenes geschütztes UUID-Verzeichnis +unter `/run`: positive interne FD-Prüfung, Verweigerung eines gleichbyteigen +Namensaustauschs sowie eines nachträglich hinzugefügten Hardlinks. Der öffentliche +API verweigert den Fixture-Elternpfad. Noch kein positiver Produktpfadtest, +keine Autorität zur Wiederaufnahme eines unklaren Applys. + +Der erste lokale Prepareversuch stoppte vor Fallanlage und SSH: Das vom +Sourceworker erzeugte private Qualifikationspaket hatte zu offene Rechte +(Verzeichnisse775, JSON664). Im gesonderten lokalen Reparaturfallf3c44696 wurden +46 eigene Objekte auf700/600, die qualifizierte Exe auf500 begrenzt; Besitzer, +Inodes und Dateibytes blieben erhalten. Der Reader wurde nicht gelockert. +Erst danach entstand der neue Originalfall349ffb0b-ec46-4eb0-b0e6-0867f3cd392b. + +Tatsächlich einmal ausgeführt, anschließend separat nur gelesen: + +```sh +python3 deploy/updater_linux_reopen_acceptance.py prepare +python3 deploy/updater_linux_reopen_acceptance.py execute --case 349ffb0b-ec46-4eb0-b0e6-0867f3cd392b +python3 deploy/updater_linux_reopen_acceptance.py read --case 349ffb0b-ec46-4eb0-b0e6-0867f3cd392b +``` + +Ergebnis auf der Cloud-Linux-VM als UID0: **6/6,0ignored/filtered, Exit0**. +Originalmanifest SHA256 +`3278a9ffbcbf460f2304f570165a4c6cb4292ef22604b9639af82088ef9b046c`; +Execute-Beleg SHA256 +`0d9a522d7e25d49af47bbe4950bde544a0f84ba9d40a8f60d067512a9638433b`; +separater Readback SHA256 +`4fc2f86a18b83bfa536d1d657eee87304db8c7ce096459c5f366940241e0b6ba`. +Die bekannten Prozess-, Boot-, Kontrollbyte- und Dateiidentitätszeugen waren +vor/nach sowie beim Readback gleich. APT inaktiv/disabled; Full aktiv, weiterhin +Autostart disabled. Keine Dienststeuerung, RMM-Jobs oder Produktdateitausche. +Der eingefrorene Fünferrunner und sein ursprünglicher Beleg bleiben unverändert. + +Auch dieser Nachweis belegt keine vollständige SQL-/PKI-Historienprüfung, +keinen geschlossenen Readercensus und keine vollständige Apply-/Health-/ +Rollbackstrecke. Windows und der Selbstupdater bleiben offen. diff --git a/docs/handover.md b/docs/handover.md index cfec641..416e7c3 100644 --- a/docs/handover.md +++ b/docs/handover.md @@ -1,5 +1,13 @@ # Übergabe — Linux-MVP abgeschlossen, Windows wird fortgesetzt +**Neuer nativer Linux-Sechsernachweis:** Quellenstand328e440/Main7d328ee, +Originalfall349ffb0b, Cloud-VM UID0:6/6 ohne Skip/Filter; separater Readback +abgeschlossen. Ein vorheriger lokaler Rechtefehler stoppte vor SSH und wurde +unter Erhalt von Inodes/Bytes behoben. Details samt Belegshashes: +[Linux-Updaterport](agent-updater-linux-native-results.md#neuer-sechsernachweis-nach-gebundenem-stage-reopen). +Keine Apply-/Rollback-/Windowsqualifikation; Full weiter Autostart disabled. + + **Quellencheckpoint1.21, noch kein Runtimewechsel:** Der zusammengehörige Updaterstand `1e89c45` ist geprüft und nach Gitea gepusht, anschließend in Main zusammengeführt. Neue Plan-/Healthschlüsselbindung, atomarer Handoff samt