diff --git a/deploy/agent_updater_contract_acceptance.py b/deploy/agent_updater_contract_acceptance.py new file mode 100644 index 0000000..48b0615 --- /dev/null +++ b/deploy/agent_updater_contract_acceptance.py @@ -0,0 +1,313 @@ +#!/usr/bin/env python3 +"""Native Linux-first qualification of the pure updater verifier, never Apply. + +prepare-local packages the already-qualified test executable without rebuilding. +Only the parent orchestrator runs linux/readback-linux, explicitly. No daemon, +product configuration, enrollment, key, policy, database or RMM job is touched. +""" +import argparse +import base64 +import hashlib +import inspect +import json +import os +from pathlib import Path +import re +import stat +import subprocess +import uuid + +import windows_msi_contract_acceptance as common + +ROOT = Path(__file__).resolve().parents[1] +STATE = ROOT / 'devstate/agent-updater-native' +PROFILE = 'agent-updater-pure-contracts-v1' +CORE_COMMIT = 'cc5c93596d0864c526b69a4f7efca805599b6ea1' +IMAGE = 'sha256:9a76ad3744ebfdddae96ca10001ce8291c1b332fb54c8df5eea0e8e999ac6fc6' +REMOTE = '/var/lib/rmm-agent-updater-contracts' +ARTIFACT_SHA = 'e3a1a3140da09de2f86055faa45faf7ba05ddddc2d92d23fef3df03a63bf2999' +ARTIFACT_BYTES = 1544584 +EXPECTED = sorted([ + 'canonical_release_and_exact_role_bytes_are_metadata_only', + 'signature_domain_bytes_unknown_key_and_revocation_are_independent', + 'signed_noncanonical_unknown_duplicate_and_oversize_payloads_are_rejected', + 'incompatible_clock_platform_state_protocol_and_trust_contexts_are_rejected', + 'monotone_floor_same_sequence_conflict_and_postrollback_state_are_preserved', + 'descriptor_roles_ids_bounds_and_digest_encoding_are_strict', + 'artifact_eof_extra_bytes_hash_and_io_errors_never_verify', + 'streamed_large_release_verifies_with_fixed_read_window', + 'keyring_rejects_weak_keys_duplicates_empty_sets_and_invalid_ranges', +]) +require = common.require +save = common.save +load = common.load +private = common.private +sha = common.sha + + +def setup(): + os.umask(0o077) + STATE.mkdir(mode=0o700, exist_ok=True) + private(STATE, True) + + +def sources(): + """Only actual core/compiler inputs; later docs/runner commits do not rebuild.""" + names = {'Cargo.toml', 'Cargo.lock'} + names.update(str(p.relative_to(ROOT)) for p in (ROOT / 'crates/updater').rglob('*') if p.is_file()) + result = {} + for name in sorted(names): + path = ROOT / name + require(path.is_file() and not path.is_symlink(), 'fixed regular core source') + committed = subprocess.run(['git', 'show', CORE_COMMIT + ':' + name], cwd=ROOT, capture_output=True, check=True).stdout + require(hashlib.sha256(committed).hexdigest() == sha(path), 'original reviewed core source') + result[name] = sha(path) + return result + + +def driver_sources(): + return {name: sha(ROOT / name) for name in ( + 'deploy/agent_updater_contract_acceptance.py', + 'deploy/windows_msi_contract_acceptance.py', + 'deploy/vm_access_check.py', + )} + + +def remote_source_sha(): + return hashlib.sha256(inspect.getsource(linux_case).encode()).hexdigest() + + +def prepare(qualification): + setup() + require(qualification.absolute() == ROOT / 'devstate/agent-updater/local-qualification.json', 'existing fixed local qualification') + old = load(qualification) + expected_sources = sources() + require(old['profile'] == PROFILE and old['image_id'] == IMAGE and old['target'] == 'x86_64-unknown-linux-gnu' + and old['sources'] == expected_sources and old['test_count'] == 9 and old['tests'] == EXPECTED + and old['native_cloud_vm_tested'] is False and old['agent_started'] is False and old['activation_implemented'] is False, + 'original nine local checks only') + for label in ('fmt', 'clippy', 'tests'): + check = old['checks'][label] + require(check['exit_code'] == 0 and check['log_sha256'] == sha(qualification.parent / (label + '.log')) + and check['command'][0] == 'docker' and IMAGE in check['command'], 'original local command receipt') + common.check_output((qualification.parent / 'tests.log').read_bytes(), 9) + item = old['artifact'] + original = Path(item['path']) + expected = ROOT / 'devstate/agent-updater/target/x86_64-unknown-linux-gnu/release/deps/release_contract-2aa0a51dd0c5c97d' + meta = original.lstat() + require(original == expected and stat.S_ISREG(meta.st_mode) and meta.st_nlink == 1 and meta.st_uid in (0, os.getuid()) + and item['sha256'] == sha(original) == ARTIFACT_SHA and item['bytes'] == meta.st_size == ARTIFACT_BYTES, + 'original qualified link, never rebuilt') + folder = STATE / ('prepared-' + str(uuid.uuid4())) + folder.mkdir(mode=0o700) + artifact = folder / 'updater-contracts' + fd = os.open(artifact, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, 0o600) + with os.fdopen(fd, 'wb') as output: + output.write(original.read_bytes()); output.flush(); os.fsync(output.fileno()) + require(sha(artifact) == ARTIFACT_SHA and artifact.read_bytes()[:6] == b'\x7fELF\x02\x01' + and artifact.read_bytes()[18:20] == b'\x3e\0', 'same Linux x64 delivery bytes') + def inspect_elf(*args): + return common.command(['docker', 'run', '--rm', '--network', 'none', '--read-only', + '-v', str(artifact) + ':/unit:ro', '--entrypoint', 'readelf', IMAGE, *args, '/unit'], folder).decode() + versions = inspect_elf('--version-info') + dynamic = inspect_elf('-d') + glibc = sorted(set(re.findall(r'GLIBC_(\d+\.\d+)', versions)), key=lambda n: tuple(map(int, n.split('.')))) + require(glibc and tuple(map(int, glibc[-1].split('.'))) <= (2, 34), 'known Cloud Linux GLIBC compatibility') + manifest = dict(schema_version=1, profile=PROFILE, core_commit=CORE_COMMIT, + local_qualification_path=str(qualification.absolute()), local_qualification_sha256=sha(qualification), + core_sources=expected_sources, driver_sources=driver_sources(), remote_source_sha256=remote_source_sha(), + artifact=dict(path=str(artifact), sha256=sha(artifact), bytes=artifact.stat().st_size, + glibc_max=glibc[-1], needed=sorted(re.findall(r'Shared library: \[([^\]]+)\]', dynamic))), + test_names=EXPECTED, test_count=9, test_executable_rebuilt=False, + local_only=True, native_cloud_vm_tested=False, agent_started=False, activation_implemented=False) + save(folder / 'manifest.json', manifest) + print(json.dumps(dict(manifest=str(folder / 'manifest.json'), manifest_sha256=sha(folder / 'manifest.json'), + tests=9, rebuilt=False, native_executed=False))) + + +def verified(path, new_case): + path = path.absolute() + require(path.name == 'manifest.json' and path.parent.parent == STATE + and re.fullmatch(r'prepared-[0-9a-f-]{36}', path.parent.name), 'fixed native manifest path') + private(path.parent, True) + value = load(path) + require(value['schema_version'] == 1 and value['profile'] == PROFILE and value['core_commit'] == CORE_COMMIT + and value['driver_sources'] == driver_sources() and value['remote_source_sha256'] == remote_source_sha() + and value['test_names'] == EXPECTED and value['test_count'] == 9 + and value['test_executable_rebuilt'] is False and value['native_cloud_vm_tested'] is False, + 'original reviewed core and native driver') + if new_case: + require(value['core_sources'] == sources(), 'new native case needs same core') + item = value['artifact'] + require(Path(item['path']) == path.parent / 'updater-contracts' + and item['sha256'] == ARTIFACT_SHA and item['bytes'] == ARTIFACT_BYTES, 'fixed delivery tuple') + private(item['path']) + require(sha(item['path']) == ARTIFACT_SHA and Path(item['path']).stat().st_size == ARTIFACT_BYTES, + 'retained immutable delivery') + return value + + +def linux_case(p): + """Sent only by the parent to the fixed Cloud Linux bootstrap endpoint.""" + import resource + ident = str(uuid.UUID(p['id'])) + require(ident == p['id'] and p['profile'] == 'agent-updater-pure-contracts-v1' + and p['action'] in ('prepare', 'run', 'read') and p['test_count'] == 9 and len(p['names']) == 9, + 'fixed pure updater case') + require(os.geteuid() == 0 and os.uname().machine == 'x86_64', 'fixed Cloud Linux bootstrap architecture') + root = Path('/var/lib/rmm-agent-updater-contracts') + def safe(path, directory, executable=False): + item = path.lstat() + require(item.st_uid == 0 and stat.S_IMODE(item.st_mode) == (0o700 if directory else 0o500 if executable else 0o600) + and (stat.S_ISDIR(item.st_mode) if directory else stat.S_ISREG(item.st_mode) and item.st_nlink == 1), 'private unit object') + def write(path, value): + fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_WRONLY | os.O_NOFOLLOW, 0o600) + with os.fdopen(fd, 'w') as output: + json.dump(value, output); output.flush(); os.fsync(output.fileno()) + directory = os.open(path.parent, os.O_DIRECTORY | os.O_RDONLY) + try: os.fsync(directory) + finally: os.close(directory) + def read(path): + safe(path, False); require(path.stat().st_size <= 2 * 1024 * 1024, 'bounded original unit receipt') + return json.loads(path.read_bytes()) + os.umask(0o077) + case = root / ident + if p['action'] == 'read' and not case.exists(): + return dict(id=ident, status='remote_case_absent') + if p['action'] == 'prepare': + if not root.exists(): root.mkdir(mode=0o700) + safe(root, True); case.mkdir(mode=0o700); write(case / 'intent.json', p) + return dict(id=ident, prepared=True) + safe(root, True); safe(case, True) + original = read(case / 'intent.json') + require({k:v for k,v in p.items() if k != 'action'} == {k:v for k,v in original.items() if k != 'action'}, 'exact original unit intent') + if p['action'] == 'read': + if (case / 'result.json').exists(): return read(case / 'result.json') + partial = {name:read(case / name) for name in ('listing.json',) if (case / name).exists()} + return dict(id=ident, status='started_without_result' if (case / 'started.json').exists() else 'prepared_without_start', partial=partial) + write(case / 'started.json', dict(execute_once=True, manifest_sha256=p['manifest_sha256'])) + binary = case / 'updater-contracts'; safe(binary, False) + require(binary.stat().st_size == p['artifact']['bytes'] == 1544584 + and hashlib.sha256(binary.read_bytes()).hexdigest() == p['artifact']['sha256'] == 'e3a1a3140da09de2f86055faa45faf7ba05ddddc2d92d23fef3df03a63bf2999', 'exact reviewed updater test executable') + binary.chmod(0o500); safe(binary, False, True) + temporary = case / 'tmp'; temporary.mkdir(mode=0o700) + env = {'PATH':'/usr/bin:/bin', 'LANG':'C.UTF-8', 'LC_ALL':'C.UTF-8', 'TMPDIR':str(temporary), 'RUST_BACKTRACE':'0'} + def limits(): + resource.setrlimit(resource.RLIMIT_CORE, (0, 0)) + resource.setrlimit(resource.RLIMIT_CPU, (15, 15)) + resource.setrlimit(resource.RLIMIT_FSIZE, (1048576, 1048576)) + resource.setrlimit(resource.RLIMIT_AS, (256 * 1024 * 1024, 256 * 1024 * 1024)) + require(subprocess.run(['/usr/bin/unshare','--net','--','/usr/bin/true'], env=env, capture_output=True, timeout=3).returncode == 0, 'isolated network namespace required') + listed = subprocess.run(['/usr/bin/unshare','--net','--',str(binary),'--list','--format','terse'], cwd=case, + env=env, capture_output=True, timeout=5, preexec_fn=limits) + require(listed.returncode == 0 and len(listed.stdout) <= 65536 and not listed.stderr, 'bounded actual test list') + lines = listed.stdout.decode().splitlines() + require(all(not line.strip() or __import__('re').fullmatch(r'[A-Za-z0-9_:]+: test', line) for line in lines), 'terse fixed test names only') + actual = sorted(line[:-6] for line in lines if line.endswith(': test')) + write(case / 'listing.json', dict(names=actual, sha256=p['artifact']['sha256'], exit_code=listed.returncode)) + require(actual == p['names'] and len(set(actual)) == 9, 'all nine exact names before test execution') + write(case / 'tests-started.json', dict(execute_once=True)) + with (case / 'stdout.bin').open('xb') as output, (case / 'stderr.bin').open('xb') as errors: + timed = False + try: + code = subprocess.run(['/usr/bin/unshare','--net','--',str(binary),'--test-threads=1'], cwd=case, env=env, + stdin=subprocess.DEVNULL, stdout=output, stderr=errors, timeout=20, preexec_fn=limits).returncode + except subprocess.TimeoutExpired: timed = True; code = None + output.flush(); errors.flush(); os.fsync(output.fileno()); os.fsync(errors.fileno()) + raw, errors = [(case / name).read_bytes() for name in ('stdout.bin', 'stderr.bin')] + require(len(raw) <= 1048576 and len(errors) <= 1048576, 'bounded original native output') + result = dict(id=ident, profile=p['profile'], platform='linux', manifest_sha256=p['manifest_sha256'], + runner_sha256=p['runner_sha256'], remote_source_sha256=p['remote_source_sha256'], core_commit=p['core_commit'], + artifact=p['artifact'], names=actual, exit_code=code, timed_out=timed, + stdout_b64=base64.b64encode(raw).decode(), stderr_b64=base64.b64encode(errors).decode(), + network_namespace=True, environment_cleared=True, list_before_run=True, + product_state_writes=False, rmm_jobs=False, activation_implemented=False) + write(case / 'result.json', result) + return result + + +def rpc(prefix, payload, folder): + code = 'import os,json,subprocess,base64,hashlib,uuid\nfrom pathlib import Path\nimport stat\n' + code += inspect.getsource(common.require) + '\n' + inspect.getsource(linux_case) + code += '\ntry:\n print(json.dumps(linux_case(' + repr(payload) + ')))\nexcept Exception as e:\n print(json.dumps(dict(bootstrap_error=True,error_class=type(e).__name__)))\n' + return common.transport(prefix, 'python3 -', code.encode(), folder) + + +def check_result(value, payload): + for name in ('id', 'profile', 'manifest_sha256', 'runner_sha256', 'remote_source_sha256', 'core_commit', 'artifact'): + require(value.get(name) == payload[name], 'complete native original tuple') + require(value.get('platform') == 'linux' and value.get('names') == EXPECTED and value.get('exit_code') == 0 + and value.get('timed_out') is False and value.get('product_state_writes') is False and value.get('rmm_jobs') is False + and value.get('activation_implemented') is False and value.get('network_namespace') is True + and value.get('environment_cleared') is True and value.get('list_before_run') is True, 'all pure native constraints') + raw = base64.b64decode(value['stdout_b64'], validate=True) + errors = base64.b64decode(value['stderr_b64'], validate=True) + require(len(raw) <= 1048576 and not errors, 'bounded clean native output') + common.check_output(raw, 9) + + +def execute(path, access_root, case_id): + is_readback = case_id is not None + setup(); path = path.absolute(); manifest = verified(path, new_case=not is_readback) + # This reads access configuration only when the parent explicitly runs native. + prefix = common.access_settings(access_root, 'linux') + if case_id is None: + case_id = str(uuid.uuid4()); folder = STATE / case_id; folder.mkdir(mode=0o700) + payload = dict(id=case_id, profile=PROFILE, manifest_sha256=sha(path), runner_sha256=sha(__file__), + remote_source_sha256=remote_source_sha(), core_commit=CORE_COMMIT, test_count=9, names=EXPECTED, + artifact={name:manifest['artifact'][name] for name in ('sha256', 'bytes')}) + save(folder / 'intent.json', dict(payload=payload, manifest_path=str(path), access_root=str(access_root))) + save(folder / 'started-local.json', dict(no_retry=True)) + else: + require(str(uuid.UUID(case_id)) == case_id, 'original canonical case') + folder = STATE / case_id; private(folder, True) + original = load(folder / 'intent.json'); load(folder / 'started-local.json') + require(original['manifest_path'] == str(path) and original['access_root'] == str(access_root), 'same-case access and manifest') + payload = original['payload'] + require(payload['id'] == case_id and payload['runner_sha256'] == sha(__file__) + and payload['manifest_sha256'] == sha(path) and payload['remote_source_sha256'] == remote_source_sha(), 'unchanged same-case runner') + if not case_id or not (folder / 'intent.json').exists(): + raise RuntimeError('missing create-once local intent') + # Readback never resumes upload or run, even after a lost prepare reply. + if not is_readback: + prepared = rpc(prefix, dict(payload, action='prepare'), folder) + save(folder / 'prepared-remote.json', prepared) + require(prepared == dict(id=case_id, prepared=True), 'fresh fixed remote scratch case') + common.upload(prefix, manifest['artifact'], REMOTE + '/' + case_id + '/updater-contracts', folder, 'updater-contracts') + result = rpc(prefix, dict(payload, action='read' if is_readback else 'run'), folder) + save(folder / ('readback-' + str(uuid.uuid4()) + '.json'), result) + if result.get('status'): + require(is_readback and result.get('id') == case_id and result['status'] in ('remote_case_absent','prepared_without_start','started_without_result'), 'read-only original partial status') + print(json.dumps(dict(verified=False, case_id=case_id, status=result['status'], retry_allowed=False))); return + check_result(result, payload) + proof = dict(verified=True, core_commit=CORE_COMMIT, manifest_sha256=sha(path), case_id=case_id, native=result) + proof_path = path.parent / 'linux-passed.json' + if proof_path.exists(): require(load(proof_path) == proof, 'preserve original native proof') + else: save(proof_path, proof) + print(json.dumps(dict(verified=True, case_id=case_id, tests=9, proof=str(proof_path), proof_sha256=sha(proof_path), activation_tested=False))) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('action', choices=('prepare-local','linux','readback-linux')) + parser.add_argument('--qualification', type=Path) + parser.add_argument('--manifest', type=Path) + parser.add_argument('--case') + parser.add_argument('--access-root', type=Path) + parser.add_argument('--execute-native-tests', action='store_true') + args = parser.parse_args() + if args.action == 'prepare-local': + require(args.qualification and not (args.manifest or args.case or args.access_root or args.execute_native_tests), 'prepare packages only existing local unit artifact') + prepare(args.qualification) + else: + require(args.manifest and args.access_root and not args.qualification, 'explicit original manifest and access root') + if args.action == 'linux': require(args.execute_native_tests and not args.case, 'explicit new native unit invocation') + else: require(args.case and not args.execute_native_tests, 'readback never executes tests') + execute(args.manifest, args.access_root, args.case) + + +if __name__ == '__main__': + try: main() + except Exception as error: + print(json.dumps(dict(error='AGENT_UPDATER_NATIVE_QUALIFICATION_INCOMPLETE', error_class=type(error).__name__, details_suppressed=True))) + raise SystemExit(2) from None diff --git a/docs/agent-updater-native-contracts.md b/docs/agent-updater-native-contracts.md new file mode 100644 index 0000000..f40f8df --- /dev/null +++ b/docs/agent-updater-native-contracts.md @@ -0,0 +1,89 @@ +# Reinen Updater-Prüfkern zuerst auf Cloud-Linux qualifizieren + +Stand 2026-11-14: Runner implementiert, lokal vorbereitet und anschließend vom +Eltern-Orchestrator **auf der Cloud-Linux-VM ausgeführt:9/9 bestanden**. +Dieser Schritt prüft ausschließlich die neun bereits lokal +bestandenen Verifierverträge. Er installiert weder Updater noch Agent/Helper, +öffnet keine Capability und führt keine Update-/Installer-/Skript-/RMM-Jobs aus. + +`deploy/agent_updater_contract_acceptance.py` bindet den unabhängig geprüften +Kerncommit `cc5c93596d0864c526b69a4f7efca805599b6ea1`, bestehende lokale +Qualification, Sourcehashes und unveränderte Testexe. Änderungen an späterer +Dokumentation erzeugen keinen falschen Rebuildbedarf. NativeDriver und die +wiederverwendeten geprüften SSH-/Receipt-Helpers erhalten eigene Sourcehashes. +Ein neuer Driverstand macht alte vorbereitete Manifeste absichtlich ungültig. + +Tatsächlich lokal ausgeführt: + +```text +python3 deploy/agent_updater_contract_acceptance.py --help +python3 deploy/agent_updater_contract_acceptance.py prepare-local --qualification /home/kevin/Schreibtisch/Coding/rust-discovery-agent-updater/devstate/agent-updater/local-qualification.json +``` + +Das bestehende Testimage wurde **nicht neu gebaut oder erneut ausgeführt**. +Originalbytes wurden create-only in den neuen geschützten Vorbereitungsordner +kopiert. Nur `readelf` lief im gepinnten Offline-Dockerimage. ELF-x64, maximale +GLIBC2.34 und benötigte dynamische Bibliotheken wurden ermittelt; native +Lader-/Ausführungsfähigkeit bleibt bis zum VM-Lauf offen. + +Lokales Manifest: +`devstate/agent-updater-native/prepared-37b4146d-cbef-431a-aa4a-9827841b8482/manifest.json`, +SHA256 `a7f0903cea77c36c4d40df5ad486161c10e55bb9a9135629a555ffafd411d521`. +Testexe unverändert1544584Bytes, SHA256 +`e3a1a3140da09de2f86055faa45faf7ba05ddddc2d92d23fef3df03a63bf2999`. +Python-/erzeugte Remotequellsyntax sowie sechs Ergebnis-Verweigerungsfälle, +Readback-ohne-Upload/-Run und fehlendes Native-Opt-in wurden lokal mit +Transport-Mocks geprüft; keine SSH-Verbindung und kein erneuter Unitlauf. + +**Anschließend tatsächlich durch den Eltern-Orchestrator ausgeführt:** + +```text +python3 deploy/agent_updater_contract_acceptance.py linux --manifest /home/kevin/Schreibtisch/Coding/rust-discovery-agent-updater/devstate/agent-updater-native/prepared-37b4146d-cbef-431a-aa4a-9827841b8482/manifest.json --access-root /home/kevin/Schreibtisch/Coding/rust-discovery --execute-native-tests +``` + +Der Runner liest erst bei diesem expliziten Aufruf die bereits vorhandene streng +geparste Linuxzugangskonfiguration aus dem Maincheckout. Ausschließlich der feste +Cloudclient `root@116.203.20.85`, vorhandener SSH-Key und bestätigter Hostkey sind +zulässig. Keine Zugangsdaten im Argument-/Ergebnispayload oder Chat. + +Remote wird ein neuer rootprivater Fall unter +`/var/lib/rmm-agent-updater-contracts/` einmal angelegt. Die exakt gehashte +Testexe muss vor Start alle neun erwarteten Testnamen melden. Sie läuft mit +geleerter Umgebung, eigener Scratchdirectory, Netzwerknamespace und CPU-/RAM-/ +Outputlimits. Vor dem einzigen Lauf steht der dauerhafte Create-once-Startmarker. +Bei verlorenem Reply niemals `linux` erneut ausführen oder neu hochladen. +Die ursprüngliche UUID steht im lokalen +`devstate/agent-updater-native//intent.json`; anschließend ausschließlich: + +```text +python3 deploy/agent_updater_contract_acceptance.py readback-linux --manifest /home/kevin/Schreibtisch/Coding/rust-discovery-agent-updater/devstate/agent-updater-native/prepared-37b4146d-cbef-431a-aa4a-9827841b8482/manifest.json --access-root /home/kevin/Schreibtisch/Coding/rust-discovery --case +``` + +Readback liest Ergebnis oder tatsächlichen Teilstatus desselben Falls. Es darf +weder Upload noch Unitstart fortsetzen. Fehlender/unklarer Abschluss bleibt +`verified=false`, `retry_allowed=false`. Erst vollständig geprüfte Original- +Ergebnisse9/9 ohne Skip schreiben `linux-passed.json`. Dieser Nachweis ist auch +dann **nur native Kernqualifikation**, keine erfolgreiche Agentaktualisierung, +WebUI-Abnahme, Windowsqualifikation oder Produktdienst-/Capabilityfreigabe. + +## Tatsächlicher Cloud-Linux-Nachweis + +Rootfall `420d53da-6e34-4e04-b871-0b571d8d3fc4` auf dem festgelegten Cloudclient +`116.203.20.85`: Der Runner prüfte zuerst die vollständige tatsächliche Liste +der neun erwarteten Tests und führte danach exakt diese neun ohne Skip aus. +Exitcode0, kein Timeout und keine Fehlerausgabe. Geleerte Umgebung, +Netzwerknamespace und unveränderte gehashte Originaltestexe sind im Ergebnis +gebunden. Keine Produktzustandsänderung und kein RMM-Job durch diese Units. + +Der geschützte lokale Beleg `linux-passed.json` neben dem oben genannten +Manifest wurde zurückgelesen und unabhängig gegen erwarteten Fall, +Manifest-/Artefakthashes und alle neun Testnamen geprüft. Proof-SHA256: +`bb98bdbd010d23e2905cdffa37b2ad38639b43c770ed2efafd7fa9ac8a22f9d4`. +Die tatsächliche VM-Ausführung erfolgte durch Root; der Verifier-Subagent +führte weiterhin keine eigene SSH-/VM-Aktion aus. + +Damit ist der **reine Linux-Prüfkern nativ qualifiziert**. Windows-Build und +native Windows-Units sind getrennt noch offen. Selbstupdateinstallation, +Releasekatalog/Streamingtransport, feste Plan-/Grant-/WebUI-Bindung, +Updaterprozess und Code-/Pin-Aktivierung/Health/Rollback bleiben unverändert +offen. Dieser Erfolg bescheinigt keinen vollständigen Agent-Autoupdater. diff --git a/docs/agent-updater-proposal.md b/docs/agent-updater-proposal.md index 116d659..d4c7012 100644 --- a/docs/agent-updater-proposal.md +++ b/docs/agent-updater-proposal.md @@ -259,9 +259,13 @@ bindet Quellen, Image-ID, tatsächliche Befehle/Loghashes und alle neun Testname Die Linux-Release-Testexe ist1544584Bytes groß, SHA256 `e3a1a3140da09de2f86055faa45faf7ba05ddddc2d92d23fef3df03a63bf2999`. Das ist ein lokaler Container-/Vertragsnachweis, **kein Cloud-VM-Nachweis**. -Native Linux-Test-VM vor Windows, Serverintegration und tatsächlicher -genehmigter Codewechsel bleiben offen. Kein Installer-/VM-Aufruf, keine -Dienständerung, keine Freigabe und kein RMM-Job durch diesen Quellschnitt. +Der danach durch Root ausgeführte eigene Native-Linux-Schritt bestand9/9 +auf der Cloud-Test-VM, Fall `420d53da-6e34-4e04-b871-0b571d8d3fc4`, +Proof-SHA256 `bb98bdbd010d23e2905cdffa37b2ad38639b43c770ed2efafd7fa9ac8a22f9d4`. +Details und klare Grenzen: [Native Kernqualifikation](agent-updater-native-contracts.md). +Windows, Serverintegration und tatsächlicher genehmigter Codewechsel bleiben +offen. Kein Installer, keine Dienständerung, keine Freigabe und kein RMM-Job +durch diesen reinen Prüfkern; der Subagent führte keine eigene VM-Aktion aus. ## Nächster Integrationsschnitt zur Freigabe: fester Codepaar-Updatejob