Qualify five isolated Linux updater OS units on cloud VM
Rust development slice / linux (push) Failing after 7s

This commit is contained in:
2026-11-14 21:04:14 +01:00
parent 6d4c75e886
commit c35c440ac3
2 changed files with 436 additions and 0 deletions
+313
View File
@@ -0,0 +1,313 @@
#!/usr/bin/env python3
"""Frozen five 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/updater-linux-execfix-aa106c58-8c96-4c8a-8490-635b1d143f07'
STATE = ROOT / 'devstate/updater-linux-native'
PROFILE = 'rmm.updater-linux.five-os-units.v1'
RECEIPT_SHA = 'f705ba03e5043a411fc3a0642197fc4f16da8627e1e5cbfbac78ed125ecb650c'
INTENT_SHA = '4921dac74d57931ad1973b4e64409d231e02ab0cb264b35113292fc295840ad3'
BINARY_SHA = 'b11b57e6399dcfcfb255619a8fba558beea6a57e4f1ee997ee9c63c769a1e882'
BINARY_BYTES = 1538320
TESTS = sorted('''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 / 'intent.json').read_bytes()) == INTENT_SHA, 'original qualification provenance')
source = support.load(folder / 'intent.json')
support.require(len(source['source_files']) == 22 and source['source_files'] == value['source_files'], 'exact frozen 22 inputs')
for item in source['source_files']:
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-os-' + 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']) == 2051096, 'bounded binary transfer')
raw = base64.b64decode(p['binary_b64'], validate=True)
require(len(raw) == 1538320 and hashlib.sha256(raw).hexdigest() == p['binary_sha256'], 'fixed five-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) == 5 and sorted(line[:-6] for line in lines if line.endswith(': test')) == p['tests'], 'exact five 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'5 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']), 'five native units and retained target state')
receipt = dict(id=ident, profile=p['profile'], passed=5, 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 / 'intent.json')
support.require(sha((QUALIFICATION / 'intent.json').read_bytes()) == INTENT_SHA
and receipt['intent_sha256'] == INTENT_SHA and len(original['source_files']) == 22
and receipt['actual_fixed_tests'] == {'passed': 5, 'failed': 0, 'ignored': 0, 'filtered': 0}
and receipt['old_code_counterexample_expected_failed'] is True, 'reviewed five-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 / 'intent.json', folder / 'intent.json', INTENT_SHA, (QUALIFICATION / 'intent.json').stat().st_size)
paths = set()
for item in original['source_files']:
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 = Path(receipt['binary']['path'])
support.require(binary == QUALIFICATION / 'target/release/deps/rmm_updater_linux-b7e2b2ad3deb3b92', '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['source_files'], 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()
+123
View File
@@ -0,0 +1,123 @@
# Linux-Updaterport: nativer Fünfertest 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
Windows-Erfolgsnachweis. Der einmalige Lauf und der separate lesende Originalfall-Readback sind
abgeschlossen.
## Feste Herkunft und Testmenge
Der neue Runner `deploy/updater_linux_native_acceptance.py` kopiert beim lokalen
`prepare` die 22 Originalinputs aus dem eingefrorenen Korrektursnapshot
`devstate/updater-linux-execfix-aa106c58-8c96-4c8a-8490-635b1d143f07/source`
im benachbarten Updaterworktree. Er prüft deren einzelne Hashes und Längen gegen
den unveränderten Intent mit SHA256
`4921dac74d57931ad1973b4e64409d231e02ab0cb264b35113292fc295840ad3`.
Kein Lesen aktueller WIP-Quellen oder Ersatz durch andere Gitblobs.
Der unabhängig geprüfte lokale Receipt ist
`f705ba03e5043a411fc3a0642197fc4f16da8627e1e5cbfbac78ed125ecb650c`;
die feste vorhandene Testexe hat1538320Byte und SHA256
`b11b57e6399dcfcfb255619a8fba558beea6a57e4f1ee997ee9c63c769a1e882`.
Der Runner baut keine neue Exe. Sein eigener Hash, die Transportquellen und die
22 kopierten Inputs werden in einem eigenen lokalen Fallmanifest gebunden und
vor jedem späteren Aufruf erneut geprüft.
Die komplette native Testliste muss vor Ausführung exakt diese fünf Namen haben:
- `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`
Die letzte Probe hält tatsächlich dieselbe PID, Prozessgeburt und UID/GID beim
Wechsel von eigenem Bash zu eigenem Sleep. Sie verlangt die Ablehnung des alten
Imagebelegs. Lokal bestand die korrigierte Generation5/5; die zusätzliche Probe
scheiterte mit dem ursprünglichen Processcode gezielt an dieser Ablehnung.
Diese bestehenden lokalen Ergebnisse wurden nur gelesen, nicht erneut gebaut
oder ausgeführt und nicht zu einem nativen Cloudnachweis umgedeutet.
## Enger Zielumfang und Ausführung
Root ist hier erforderlich: Die vorhandenen Testquellen verlangen UID0,
erstellen eigene geschützte UUID-Verzeichnisse unter `/run` und prüfen eigene
UID/GID0-Prozesse. Der feste Prozess startet mit geleerten Zusatzgruppen,
`no-new-privs` und bereinigter Umgebung. Er benötigt weder Capabilities aus dem
RMM-Protokoll noch eine Dienstinstallation. Die Tests verwenden eigene Dateien,
Hardlinks, Symlinks, Socketpairs und eigene Bash-/Sleep-Kinder. Sie öffnen keinen
Updaterlistener, kein RMM-Ledger und keine tatsächlichen Installationsziele.
Der Runner hält seine eigenen Kommandogruppen bis zur Bereinigung gegen
PIDwiederverwendung fest und beendet bei Timeout ausschließlich diese Gruppen.
Der Operator verwendet den bestehenden streng geprüften Cloud-Linux-SSH-Pfad
aus Main. Der Runner liest Credentials ausschließlich bei `execute`/`read`
über den vorhandenen Parser, keine kopierten Credentials, keine Hostkeyausnahme.
Nur die gebundene Testexe wird größenbegrenzt übertragen und auf der VM erneut
gehasht. Das neue Remoteverzeichnis ist exklusiv
`/var/tmp/rmm-updater-linux-os-<UUID>`, Rootbesitz,0700. Binärdatei und Belege
werden create-only geschrieben und geflusht, einschließlich Elternverzeichnis.
Vorher/nachher werden Ubuntu24.04/x86-64 und Boot, die drei tatsächlichen
Agent-/General-/Full-Prozessgenerationen mit Konten/Image/InvocationID, vier
bekannte geschützte Config-/Pin-/Unitdateien mit Rohhash/Metadaten sowie drei
DB- und eine Executorlock-Dateiidentität verglichen. APT muss weiterhin
inaktiv und deaktiviert sein. `systemctl show` wird ausschließlich lesend
verwendet; kein Start/Stop/Enable, kein Paketbefehl und kein Reboot.
Tatsächlich einmalig ausgeführt (Originalfall
`ec030323-85df-4b38-9e70-87be330033c2`):
```sh
python3 deploy/updater_linux_native_acceptance.py prepare
python3 deploy/updater_linux_native_acceptance.py execute --case ec030323-85df-4b38-9e70-87be330033c2
python3 deploy/updater_linux_native_acceptance.py read --case ec030323-85df-4b38-9e70-87be330033c2
```
Ein exklusiver lokaler Executeeintrag wird vor SSH dauerhaft geschrieben.
Bei verlorenem Reply ausschließlich denselben Fall lesen. Keine Wiederholung,
keine neue Testgeneration und kein neuer Fall zur Umgehung eines unklaren Laufs.
Fehlt ein Endbeleg, meldet Readback dies ausdrücklich; daraus entsteht kein
Erfolg. Der Remote-Einmalmarker und exklusive Ordner verweigern ebenfalls einen
zweiten Lauf. Ein vollständiger Erfolg verlangt5/5 ohne Ignored/Filter sowie
unveränderte Vor-/Nachzeugen und getrennten lesenden Readback.
## Tatsächlich lokal geprüft und verbleibende Grenzen
Python-Syntax, begrenzte Ausgabeerfassung, eigener Timeout samt
Kommandogruppenbereinigung und die feste Base64-Transferlänge wurden lokal
geprüft. Keine VM-/SSH-/Serveraktion, kein RMM-Job, keine WebUI-Genehmigung und
kein neuer Cargo-Build/-Test durch diesen Vorbereitungsschritt.
Die Zeugen vergleichen bekannte Kontrollbytes und Dateiidentitäten, keine
vollständigen SQL-/PKI-Historien. Die drei Dienstprozesse werden vor und nach
beobachtet; der Runner hält deren Handles nicht durchgehend. Die innerhalb der
Unit geprüften pidfds betreffen ausschließlich eigene Fixtureprozesse.
Rootausführung eines vorab geprüften Testbinary ist keine Betriebssandbox.
Fehlschlag kann eigene Fixtureverzeichnisse hinterlassen; kein automatisches
Löschen oder Wiederholen nach unklarem Ende.
Der isolierte Linuxport besitzt weiterhin keine vollständige ledgergebundene
Engine/Fence, keinen dauerhaften Updaterdienst und keinen freigegebenen
Dateipaarwechsel. Dienststop, Ledgerübergabe, Staging/Swap, Health, Rückgabe und
Rollback des tatsächlichen Agentupdates bleiben eigene offene Integration und
anschließende WebUI-genehmigte Linux-first-Abnahme. Der bestehende Acht-Kernel-
Runner, sein nativer Nachweis und die ursprünglichen Releaseverifier-Runner
bleiben unverändert.
## Tatsächlicher nativer Endbeleg
Der geprüfte Runner SHA256 `a13e3554d27fce14848ff30e2d86430bb462f45d19fcd9acca78480c970eeb38`
übertrug ausschließlich die feste Testexe, prüfte zuerst die vollständige
Fünferliste und führte sie einmal aus. Ergebnis5/5,0ignored/filtered, Exit0,
kein stderr. Der separate Readback meldet denselben abgeschlossenen Fall
und identische aktuelle Vor-/Nachzeugen.
Execute-Beleg SHA256 `2b8bff59f158a204f669f1df9b022fac0024248de3fe035a1f11b7f532574a1a`;
Readback SHA256 `e9bdfed8919f283a917ebf06d5354832df8634a5cbb44210cdca6684e425931a`.
Die Rohbelege und22 eingefrorenen Inputs bleiben gitignoriert.
Die Full-Helper-Unit war und bleibt aktiv, aber für Autostart deaktiviert.
Dieser isolierte Unitlauf ändert diese Einstellung nicht und belegt keine
Bereitschaft nach einem Neustart. Keine RMM-Jobs oder Servicekontrolle.
Der MVP einschließlich Windows und vollständigem Selbstupdater ist weiterhin
nicht abgeschlossen.