test: prove signed updater verifier contracts on cloud Linux
Rust development slice / linux (push) Failing after 7s

This commit is contained in:
2026-11-14 16:04:42 +01:00
parent cc5c93596d
commit 668369a1f2
3 changed files with 409 additions and 3 deletions
+313
View File
@@ -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
+89
View File
@@ -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/<UUID>` 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/<UUID>/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 <ursprüngliche-UUID>
```
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.
+7 -3
View File
@@ -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