test: prove signed updater verifier contracts on cloud Linux
Rust development slice / linux (push) Failing after 7s
Rust development slice / linux (push) Failing after 7s
This commit is contained in:
@@ -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
|
||||
@@ -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.
|
||||
@@ -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
|
||||
|
||||
|
||||
Reference in New Issue
Block a user