diff --git a/deploy/server_time_source_pin_bootstrap.py b/deploy/server_time_source_pin_bootstrap.py new file mode 100644 index 0000000..9abd9ea --- /dev/null +++ b/deploy/server_time_source_pin_bootstrap.py @@ -0,0 +1,374 @@ +#!/usr/bin/env python3 +"""Create only the public Chrony pin and private runtime directories; no signer/service. + +Run with python3 -I. A failed or uncertain pin phase is never retried. host-read +reads the original case and bounded target metadata without querying time. +""" +import argparse +import hashlib +import importlib.util +import json +import os +from pathlib import Path +import re +import stat +import struct +import sys +import uuid + +OPERATOR_SHA = 'ecb72b7cbcc1d036a0f4bd2f0a92a9b80339326068e49edd70d5627226833d61' +OPERATOR = Path('/var/lib/rmm-time-source-operators') / OPERATOR_SHA / 'operator.py' +CASES = Path('/var/lib/rmm-time-source-bootstrap') +ETC = Path('/etc/rmm-time-source') +RUN = Path('/run/rmm-time-source') +PROFILE = 'rmm.public-chrony-pin.bootstrap.v1' +PROVIDER_SHA = '3fd9c7a969a583abf97e29165135a8c1044db5c951ad8bd4dbfee3ee77e7ccdc' +PIN_KEYS = {'schema_version', 'daemon_pid', 'daemon_birth_ticks', 'daemon_uid', 'daemon_gid', 'daemon_image_sha256'} + + +class Denied(RuntimeError): + pass + + +def require(value, reason): + if not value: + raise Denied(reason) + + +def encoded(value): + return (json.dumps(value, sort_keys=True, separators=(',', ':'), ensure_ascii=True) + '\n').encode('ascii') + + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + + +def identity(info): + return {name: getattr(info, 'st_' + name) for name in + ('dev', 'ino', 'uid', 'gid', 'mode', 'nlink', 'size', 'mtime_ns', 'ctime_ns')} + + +def stable_directory(info): + return {name: getattr(info, 'st_' + name) for name in ('dev', 'ino', 'uid', 'gid', 'mode')} + + +def directory(path): + require(path.is_absolute(), 'fixed_absolute_directory') + fd = os.open('/', os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW) + try: + require(os.fstat(fd).st_uid == 0 and os.fstat(fd).st_mode & 0o022 == 0, 'root_directory_protected') + for part in path.parts[1:]: + require(part not in ('', '.', '..'), 'canonical_directory') + next_fd = os.open(part, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW, dir_fd=fd) + os.close(fd) + fd = next_fd + item = os.fstat(fd) + require(item.st_uid == 0 and item.st_mode & 0o022 == 0, 'root_protected_directory') + return fd + except BaseException: + os.close(fd) + raise + + +def read_file(path, limit=1024 * 1024, mode=0o600): + parent = directory(path.parent) + try: + fd = os.open(path.name, os.O_RDONLY | os.O_NOFOLLOW, dir_fd=parent) + try: + before = identity(os.fstat(fd)) + require(stat.S_ISREG(before['mode']) and before['uid'] == before['gid'] == 0 and + before['nlink'] == 1 and stat.S_IMODE(before['mode']) == mode and before['size'] <= limit, + 'bounded_original_root_file') + raw = bytearray() + while len(raw) <= limit: + part = os.read(fd, min(65536, limit + 1 - len(raw))) + if not part: + break + raw.extend(part) + raw = bytes(raw) + require(len(raw) == before['size'] and len(raw) <= limit and before == identity(os.fstat(fd)) == + identity(os.stat(path.name, dir_fd=parent, follow_symlinks=False)), 'original_file_stable') + return raw, before + finally: + os.close(fd) + finally: + os.close(parent) + + +def parsed(raw): + def pairs(items): + result = {} + for key, value in items: + require(key not in result, 'duplicate_json_field') + result[key] = value + return result + return json.loads(raw.decode('ascii'), object_pairs_hook=pairs, + parse_constant=lambda _: (_ for _ in ()).throw(Denied('finite_json'))) + + +def load_operator(): + raw, proof = read_file(OPERATOR, 128 * 1024) + require(sha(raw) == OPERATOR_SHA, 'reviewed_operator_sha256') + # Execute exactly the checked held bytes, avoiding a second import-path read. + module = importlib.util.module_from_spec(importlib.util.spec_from_loader('rmm_reviewed_time_operator', loader=None)) + module.__file__ = str(OPERATOR) + exec(compile(raw, str(OPERATOR), 'exec'), module.__dict__) + module_guard = lambda: require(read_file(OPERATOR, 128 * 1024) == (raw, proof), 'reviewed_operator_unchanged') + return module, module_guard + + +def case_path(value): + require(str(uuid.UUID(value)) == value and uuid.UUID(value).version == 4, 'canonical_original_case') + path = CASES / value + fd = directory(path) + try: + require(stat.S_IMODE(os.fstat(fd).st_mode) == 0o700, 'private_original_case') + finally: + os.close(fd) + return path + + +def observation_key(value): + # All process, socket, pidfile, unit, fixed image and runtime metadata are + # original witnesses. Never derive a new authority from only a caller PID. + keys = ('builder', 'runtime', 'boot_id', 'chrony_observation', 'chrony_binding', 'chrony_image_metadata') + require(all(key in value for key in keys), 'complete_original_observation') + return parsed(encoded({key: value[key] for key in keys})) + + +def source_items(items): + require(type(items) is list and 12 <= len(items) <= 30, 'bounded_source_item_set') + names = set() + for item in items: + require(type(item) is dict and set(item) == {'path', 'bytes', 'sha256'}, 'exact_source_item_fields') + name = item['path'] + require(type(name) is str and (name in ('Cargo.toml', 'Cargo.lock', 'rust-toolchain.toml', + 'provenance/Cargo.toml', 'provenance/Cargo.lock', + 'crates/time-source-linux/examples/operator_probe.rs') or + re.fullmatch(r'crates/(?:time-attestation|time-source-linux|time-broker-linux)/(?:Cargo\.toml|src/[a-z_]+\.rs)', name)) and + name not in names and type(item['bytes']) is int and 0 < item['bytes'] <= 1024 * 1024 and + type(item['sha256']) is str and re.fullmatch('[0-9a-f]{64}', item['sha256']), + 'closed_source_item_path_hash_size') + names.add(name) + return names + + +class Original: + def __init__(self, case, operator, operator_guard): + self.case, self.operator, self.operator_guard = case, operator, operator_guard + self.records = {} + for name in ('preflight', 'stage', 'build'): + require(not (case / name / 'failure.json').exists(), 'original_phase_failed') + raw, proof = read_file(case / name / 'result.json') + self.records[name] = (raw, proof) + preflight, stage, build = (parsed(self.records[name][0]) for name in ('preflight', 'stage', 'build')) + require(build.get('exit_code') == 0 and build.get('runtime_metadata_equal') is True and + build.get('native_source_quality_tested') is False and build.get('artifacts') and + set(build['artifacts']) == {'rmm-time-broker-linux', 'examples/operator_probe'}, 'successful_original_arm_build') + self.expected = observation_key(preflight) + require(observation_key(build['before']) == self.expected == observation_key(build['after']), + 'original_build_chrony_runtime_boot_stable') + manifest_raw, _ = read_file(case / 'workspace/manifest.json') + manifest = parsed(manifest_raw) + source_items(manifest['source_files']) + source_items(manifest['package_files']) + require(manifest.get('operator_sha256') == OPERATOR_SHA and + re.fullmatch('[0-9a-f]{40}', manifest.get('public_commit', '')) and + sha(manifest_raw) == stage['manifest_sha256'] == build['staged_manifest_sha256'] and + manifest['package_files'] == stage['package_files'] and + manifest['public_commit'] == stage['public_commit'], 'original_source_manifest_binding') + source = [item for item in manifest['source_files'] if item['path'] == 'crates/time-source-linux/src/native.rs'] + require(len(source) == 1 and source[0]['sha256'] == PROVIDER_SHA, 'reviewed_provider_permission_fix') + tar_raw, _ = read_file(case / 'source.tar', 2 * 1024 * 1024) + require(sha(tar_raw) == stage['source_tar_sha256'], 'original_source_archive_hash') + self.source_sha = sha(tar_raw) + self.manifest_sha = sha(manifest_raw) + self.source_records = {case / 'source.tar': read_file(case / 'source.tar', 2 * 1024 * 1024), + case / 'workspace/manifest.json': read_file(case / 'workspace/manifest.json')} + require(self.source_records[case / 'source.tar'][0] == tar_raw and + self.source_records[case / 'workspace/manifest.json'][0] == manifest_raw, 'original_source_read_stable') + self.artifacts = {} + for name, recorded in build['artifacts'].items(): + path = case / 'build/artifacts' / Path(name).name + raw, proof = read_file(path, 32 * 1024 * 1024, 0o500) + actual = {'bytes': len(raw), 'sha256': sha(raw), 'elf_machine': 183} + require(raw[:6] == b'\x7fELF\x02\x01' and len(raw) >= 20 and + struct.unpack(' 1 and + type(pin['daemon_birth_ticks']) is int and pin['daemon_birth_ticks'] > 0 and + pin['daemon_uid'] == pin['daemon_gid'] == 989 and + re.fullmatch('[0-9a-f]{64}', pin['daemon_image_sha256']), 'exact_public_chrony_pin_shape') + return pin + + +def absence(parent, name): + try: + os.stat(name, dir_fd=parent, follow_symlinks=False) + except FileNotFoundError: + return + raise Denied('create_only_target_already_exists') + + +def exclusive(parent, name, raw): + require(len(raw) <= 16384 and raw.isascii(), 'bounded_ascii_receipt_or_public_pin') + fd = os.open(name, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, 0o600, dir_fd=parent) + try: + view = memoryview(raw) + while view: + count = os.write(fd, view) + require(count > 0, 'complete_create_only_write') + view = view[count:] + os.fsync(fd) + finally: + os.close(fd) + os.fsync(parent) + + +def new_directory(parent, name, mode, gid, original): + original.fresh() + absence(parent, name) + os.mkdir(name, mode=0o700, dir_fd=parent) + os.fsync(parent) + fd = os.open(name, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW, dir_fd=parent) + try: + original.fresh() + os.fchown(fd, 0, gid) + original.fresh() + os.fchmod(fd, mode) + os.fsync(fd) + require(stable_directory(os.fstat(fd)) == stable_directory(os.stat(name, dir_fd=parent, follow_symlinks=False)) and + os.fstat(fd).st_uid == 0 and os.fstat(fd).st_gid == gid and + stat.S_IMODE(os.fstat(fd).st_mode) == mode, 'exact_created_directory') + return fd + except BaseException: + os.close(fd) + raise + + +def targets_metadata(): + result = {} + for path in (ETC, ETC / 'chrony-pin.json', RUN, RUN / 'clients'): + parent = -1 + try: + parent = directory(path.parent) + result[str(path)] = identity(os.stat(path.name, dir_fd=parent, follow_symlinks=False)) + except FileNotFoundError: + result[str(path)] = None + except (Denied, NotADirectoryError): + result[str(path)] = {'inspection_denied': True} + finally: + if parent >= 0: + os.close(parent) + return result + + +def host_pin(case, operator, operator_guard): + root_etc = root_run = case_fd = phase_fd = etc_fd = run_fd = clients_fd = -1 + try: + case_fd = directory(case) + absence(case_fd, 'pin') # Reject an old phase before any new preflight. + original = Original(case, operator, operator_guard) + root_etc = directory(Path('/etc')) + root_run = directory(Path('/run')) + original.fresh() + os.mkdir('pin', 0o700, dir_fd=case_fd) + os.fsync(case_fd) + phase_fd = os.open('pin', os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW, dir_fd=case_fd) + original.fresh() + intent = {'profile': PROFILE, 'case': case.name, 'operator_sha256': OPERATOR_SHA, + 'controller_sha256': sha(Path(__file__).read_bytes()), 'source_tar_sha256': original.source_sha, + 'manifest_sha256': original.manifest_sha, 'requires_targets_initially_absent': True, + 'chrony_observation': original.expected['chrony_observation'], 'boot_id': original.expected['boot_id']} + exclusive(phase_fd, 'intent.json', encoded(intent)) + absence(root_etc, ETC.name) + absence(root_run, RUN.name) + # Every target namespace/permission/content write has an independent + # fresh actual source observation. Failure leaves exact own partial state. + etc_fd = new_directory(root_etc, ETC.name, 0o700, 0, original) + pin = original.fresh() + exclusive(etc_fd, 'chrony-pin.json', encoded(pin)) + run_fd = new_directory(root_run, RUN.name, 0o710, 10001, original) + clients_fd = new_directory(run_fd, 'clients', 0o710, 989, original) + original.fresh() + actual, proof = read_file(ETC / 'chrony-pin.json', 8192) + require(actual == encoded(pin) and parsed(actual) == pin, 'exact_final_public_pin') + for path, fd in ((ETC, etc_fd), (RUN, run_fd), (RUN / 'clients', clients_fd)): + require(stable_directory(path.lstat()) == stable_directory(os.fstat(fd)), 'final_created_directory_identity') + result = {'profile': PROFILE, 'case': case.name, 'public_pin_sha256': sha(actual), + 'public_pin_metadata': proof, 'targets': targets_metadata(), + 'operator_sha256': OPERATOR_SHA, 'source_tar_sha256': original.source_sha, + 'manifest_sha256': original.manifest_sha, 'targets_initially_absent': True, 'runtime_boot_chrony_preserved': True, + 'source_quality_sampled': False, 'signer_created': False, 'services_started': False} + original.fresh() + exclusive(phase_fd, 'result.json', encoded(result)) + print(encoded({'case': case.name, 'phase': 'pin', 'result': result}).decode('ascii'), end='') + except Exception as error: + reason = str(error) if isinstance(error, Denied) else 'unexpected_pin_bootstrap_exception' + failure = {'profile': PROFILE, 'case': case.name, 'failed': True, 'failure_reason': reason, + 'read_original_case_only': True, 'partial_objects_are_not_adoptable': True} + if phase_fd >= 0: + exclusive(phase_fd, 'failure.json', encoded(failure)) + print(encoded(failure).decode('ascii'), end='') + raise SystemExit(1) + finally: + for fd in (clients_fd, run_fd, etc_fd, phase_fd, case_fd, root_run, root_etc): + if fd >= 0: + os.close(fd) + + +def host_read(case): + records = {} + for name in ('intent', 'result', 'failure'): + path = case / 'pin' / (name + '.json') + try: + raw, proof = read_file(path, 16384) + records[name] = {'sha256': sha(raw), 'metadata': proof, 'record': parsed(raw)} + except FileNotFoundError: + records[name] = None + # Only finite lstat metadata, no commands, preflight, sockets or source sample. + print(encoded({'case': case.name, 'phase': 'pin', 'records': records, + 'target_metadata': targets_metadata(), 'read_only': True}).decode('ascii'), end='') + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('command', choices=('host-pin', 'host-read')) + parser.add_argument('--case', required=True) + args = parser.parse_args() + require(sys.flags.isolated == 1 and os.geteuid() == 0 and os.uname().sysname == 'Linux' and + os.uname().machine == 'aarch64', 'isolated_root_linux_aarch64_only') + os.umask(0o077) + case = case_path(args.case) + if args.command == 'host-read': + host_read(case) + else: + operator, operator_guard = load_operator() + host_pin(case, operator, operator_guard) + + +if __name__ == '__main__': + try: + main() + except Exception: + print(encoded({'failed': True, 'failure_reason': 'unexpected_pin_bootstrap_exception', + 'read_original_case_only': True}).decode('ascii'), end='') + raise SystemExit(1) diff --git a/docs/handover.md b/docs/handover.md index ff2d64d..95f04f4 100644 --- a/docs/handover.md +++ b/docs/handover.md @@ -1,5 +1,12 @@ # Übergabe — Linux-MVP abgeschlossen, Windows wird fortgesetzt +**Zeitprovider und Broker auf tatsächlichem ARM64-Server gebaut:** +Originalfall5b358997, Preflight/Staging und CargoRelease0, zwei tatsächliche +AArch64-Artefakte sowie separater Originalread belegt; RMM-Containermetadaten +und Boot erhalten. [Ergebnisse inklusive vorheriger101-Fälle](server-time-source-bootstrap.md). +Noch keine Qualitätsprobe, Pins, Schlüssel, Broker-/Gatewaybetrieb oder Windowsjobfreigabe. + + **Provider-Socketfix Linux-first bestanden:** Originalfall8ee39b4f, native Cloud-Linux4/4 ohne Skip/Filter, separater Originalread vollständig; bekannte Runtimezeugen erhalten.0755 akzeptiert, Gruppen-/Fremdwrite verweigert, diff --git a/docs/server-time-source-bootstrap.md b/docs/server-time-source-bootstrap.md index 96a0670..b9cd059 100644 --- a/docs/server-time-source-bootstrap.md +++ b/docs/server-time-source-bootstrap.md @@ -360,3 +360,34 @@ Receipt-SHA256 Dies ist noch kein erfolgreicher ARM64-Build. Der korrigierte Stand benötigt ein neues öffentlich gebundenes Archiv und einen eigenen tatsächlichen Buildfall; keiner der beiden Cargo101-Fälle wird wiederholt oder erfolgreich umgedeutet. + +## Tatsächlich erfolgreich: korrigierter ARM64-Build + +2026-11-15: Neuer Originalfall `5b358997-3abc-43db-945f-f41855b4e3c0` +mit öffentlichem korrigiertem Quellencheckpoint09ee24c. Preflight und Staging +bestanden; Quellenarchiv225280Bytes/SHA256 +`0da5ed0d52d3e621ef6a23cbc065f9d7c93e5683547e0a02ae3c8da8a83884a5`, +Manifest-SHA256 +`bdf7839f832e2ea0cf230a0bd8a8fbff5d4a72d8fb7ba8208e0d252bad4b56ee`. +Der native Server-ARM64-Releasebuild mit explizitem Registryfetch und +unveränderten gelockten Versions-/Checksumwerten endete mit Cargo0. +Beide erzeugten Artefakte sind ELF64/AArch64-Machine183: + +- Providerprobe848632Bytes, SHA256 + `216b4d6a0f29ef47576f5ccc469954623141e55d7b43bd73175c1d956363bbbd`. +- Broker1067136Bytes, SHA256 + `5d8d786925c060eb042f0a592453f11970c32c4287fa4c9464f6f6a6e38cb201`. + +Buildlog-SHA256 +`17498779b91081133c4030f27fa91278c1b9fd2dd4e12e1e12ac1f9cdc39adf6`, +Operatorausführungsreceipt +`a0567ec749b97c3a0d8de1a747ad7ea334de6b9b8a1bbf4c00f1220a53d0568d`, +Original-Buildresult +`58eaf0118f8f8573debfa21a295019a224b916cfc5b1a88edda426ec06bed2b5`. +Separater rein lesender Originalfallabruf bestanden, Receipt +`e95a2bd068814dd1722ceac2ac637b4cc73221b5c8f58c59ebd771a4f23be068`. +Die tatsächlichen RMM-Containermetadaten und Boot-ID sind im Buildvergleich +unverändert. Kein Provider-/Brokerstart, Zeitsetter, Pin, Schlüssel, +Gatewaydeploy oder Windowsclock-/Jobgatewechsel wurde durch den Build +ausgeführt. Der getrennt implementierte [öffentliche Pinbootstrap](server-time-source-pin-bootstrap.md) +ist die Voraussetzung der anschließenden einmaligen nativen Qualitätsprobe. diff --git a/docs/server-time-source-pin-bootstrap.md b/docs/server-time-source-pin-bootstrap.md new file mode 100644 index 0000000..9a72957 --- /dev/null +++ b/docs/server-time-source-pin-bootstrap.md @@ -0,0 +1,116 @@ +# Create-only Bootstrap für den öffentlichen Chrony-Pin + +`deploy/server_time_source_pin_bootstrap.py` implementiert ausschließlich den +öffentlichen sechs-Felder-Chrony-Pin und zwei eigene Runtimeverzeichnisse. +Signer, private Schlüssel, Broker, Systemd-Dienste, RMM-Dateien und +Chronyberechtigungen werden nicht verändert. Eine Zeitprobe oder Jobfreigabe +entsteht daraus nicht. Die Quelle ist vor einer tatsächlichen Ausführung +separat zu reviewen; Sourcevorhandensein ist keine Serverabnahme. + +Voraussetzung ist ein neuer, bereits erfolgreich geprüfter ARM64-Operatorfall +mit Preflight, Stage und Releasebuild. Das Werkzeug übernimmt dessen kanonische +UUIDv4 über `--case`, keinen frei wählbaren Pfad. Es verlangt den unveränderten +reviewten Operator +`ecb72b7cbcc1d036a0f4bd2f0a92a9b80339326068e49edd70d5627226833d61` +unter `/var/lib/rmm-time-source-operators//operator.py`: regulär, +Root:Root0600, ein Link, geschützte Rootancestry und exakte Originalbytes. +Diese geprüften Bytes werden direkt als Modul geladen, ohne einen erneuten +ungesicherten Importpfad. Der Providerquellpin ist +`3fd9c7a969a583abf97e29165135a8c1044db5c951ad8bd4dbfee3ee77e7ccdc`, +also der konkret qualifizierte Socketberechtigungsfix. + +Originale Preflight-/Stage-/Buildresultate, Quellenarchiv und Manifest werden +unabhängig gebunden. Die unveränderten Stagequellen, beide tatsächlich +AArch64-ELF183-Artefakte mit ursprünglichen Längen/Hashes und alle Original- +Zeugen vor/nach dem erfolgreichen Build bleiben Pflicht. Der aktuelle frische +Operatorpreflight muss dieselben Chrony-Prozesse, Unitgeneration, +Datei-/Socket-/Pidfileidentitäten, Boot-ID, Runtimecontainer und Buildermetadaten +belegen. Keine stille PIDübernahme, Reimage oder Neukonfiguration. + +Der Rootoperator startet ausschließlich mit isolierter Pythonumgebung: + +```text +python3 -I /reviewter/absoluter/pfad/server_time_source_pin_bootstrap.py host-pin --case +``` + +Der Pin-Schritt erhält die eigene create-only Phase `pin` im Originalfall. +Ein vorhandener Phasenpfad verweigert bereits vor einer neuen Beobachtung. +Vor der ersten Zieländerung liegen ein dauerhafter Intent und überprüfte +Originalbelege vor. Beide Topverzeichnisse müssen ursprünglich vollständig +abwesend sein, auch ein Symlink oder ein scheinbar passendes vorhandenes +Verzeichnis wird nicht übernommen: + +- `/etc/rmm-time-source`: Root:Root0700; darin ausschließlich der neue + `chrony-pin.json`, Root:Root0600, ein Link. Seine exakt sechs Felder sind + die tatsächlich erneut beobachteten Werte `schema_version`, `daemon_pid`, + `daemon_birth_ticks`, `daemon_uid`, `daemon_gid`, `daemon_image_sha256`. +- `/run/rmm-time-source`: Root:10001 0710; darin `clients`: Root:989 0710. + Kein Socket wird angelegt. Diese Pfade sind für die anschließend separat + genehmigte native Root-Providerprobe vorgesehen. + +Jede beabsichtigte Namespace-, Inhalts- oder Berechtigungsänderung wird vorher +mit einem neuen tatsächlichen Operatorpreflight gebunden. Die Verzeichnisse +entstehen zunächst Root0700; Chown und endgültiger Modus folgen jeweils nach +einer weiteren frischen Beobachtung. Gehaltene Parent-/Leaf-FDs, +`O_NOFOLLOW`, create-only Dateierzeugung, fsync und exakte Nachlese binden die +Originalobjekte. Die Schlussprüfung vergleicht den Pin bytegleich und die +vier erzeugten Objektidentitäten. Eine kleine ASCII-JSON-Receipt enthält +Hashes und öffentliche Metadaten, keine privaten Konfigurationen. + +Bei Fehlern bleiben ausschließlich die eigenen Teilobjekte und der +Fehlerbeleg erhalten. Es gibt keine automatische Bereinigung, Wiederholung, +Objektübernahme, Pinheilung oder Rücksetzung. Ein Fehler vor erfüllten +Vorbedingungen erzeugt keine Zielobjekte. Für jede verlorene oder unklare +Antwort ist ausschließlich folgender lesender Pfad vorgesehen: + +```text +python3 -I /reviewter/absoluter/pfad/server_time_source_pin_bootstrap.py host-read --case +``` + +Er liest nur vorhandene Intent-/Resultat-/Fehlerbelege und begrenzte +Zielmetadaten. Er startet keinen Operatorpreflight, Dockeraufruf, Dienst oder +Zeitsample. Nicht vertrauenswürdige Parentpfade werden geschlossen abgewiesen, +keine fremden Zielinhalte gelesen. Eine erfolgreich provisionierte Pin-Datei +ist noch kein Nachweis tatsächlicher Zeitqualität, keine Brokerinbetriebnahme +und keine Windows-Clockfreigabe. + +Lokale Quellenprüfung: AST und fünf reine Guardgruppen bestanden. Geprüft +wurden positive Originalbindung und geänderte Liveidentität, Artefakttamper / +fehlgeschlagener Build, geschlossene Quellenpfade und Providerbindung, +doppelte/nichtendliche JSON-Werte sowie create-only-/Symlink-/Längenfehler. +Ein netzloser, read-only lokaler Entwicklungscontainer prüfte zusätzlich den +vollständigen Schreibfluss auf einem eigenen Tmpfs: tatsächliche UID/GID-/ +Moduswerte, unveränderte vorhandene Objekte, Abbruch mit erhaltenem Teilzustand, +keine Wiederholung nach vorhandener Phase und kein Preflight im Lesepfad. +Die Originalautorität war dabei ausdrücklich durch eine Fixture ersetzt; +das ist kein tatsächlicher Server-, Chrony- oder ARM64-Abnahmenachweis. +Der private Quellen-/Guardfall ist +`8f2a634c-fe9e-4458-901b-aee334332baf`. Keine Zielaktion oder Gitänderung wurde +für diesen lokalen Nachweis ausgeführt. + + +ARM-Portierungsdelta: Der tatsächliche erste ARM64-Build des Rootfalls +`3564b4e7` verweigerte mit Compilerexit101, weil `libc::stat.st_nlink` dort +32 Bit besitzt. Die beiden privaten Identity-Typen in Provider und Broker +verwenden jetzt `libc::nlink_t`; Masken, Inodeprüfungen und Pinschema bleiben +unverändert. Der erwartete Providerhash dieses Bootstrapwerkzeugs ist deshalb +auf den oben genannten ARM-portablen Quellstand aktualisiert. Die zehn lokalen +Guardgruppen des Falls `8f2a634c-fe9e-4458-901b-aee334332baf` gehören weiterhin +zum vorherigen Bootstrapquellstand. Für den neuen Bootstrap wurde ausschließlich +der exakte Hashkonstantenwechsel samt AST und Quellendelta geprüft; kein neuer +ARM-Erfolg oder erneuter Zehner-Guardlauf wird daraus abgeleitet. Ursprünglicher +Compilerfehler und sämtliche alten Belege bleiben erhalten. Ein neues +Serverquellenpaket und ein neuer tatsächlicher ARM64-Build bleiben Voraussetzung. + + +JSON-Deltakorrektur vor Zielausführung: Die frische Operatorbeobachtung verwendet +bei `service_socket_fds` numerische PID-Schlüssel, gespeicherte JSON-Belege +verwenden Stringschlüssel. `observation_key` normalisiert beide Seiten jetzt +über denselben kanonischen JSON-Encoder und den strikten Parser. Kein Feld und +keine Identitätsmetadaten werden entfernt. Der kleine lokale Deltanachweis +akzeptiert die numerische/gespeicherte Darstellung desselben PID-/FD-Belegs, +verweigert weiterhin andere PID-, FD-, Inode- und Bootwerte und weist kollidierende +gemischte Schlüssel geschlossen zurück. Das Artefaktschema des unveränderten +Operators wurde direkt gegen seine AST geprüft: exakt `bytes`, `sha256`, +`elf_machine` mit AArch64-Machine183. Die bisherigen zehn Guardgruppen wurden +nicht erneut behauptet oder wiederholt; keine Zielaktion wurde ausgeführt.