diff --git a/deploy/server_time_broker_bootstrap.py b/deploy/server_time_broker_bootstrap.py index ba3b51b..19f4391 100644 --- a/deploy/server_time_broker_bootstrap.py +++ b/deploy/server_time_broker_bootstrap.py @@ -36,31 +36,12 @@ BROKER_BYTES = 1067136 SERVER = Path('/opt/rust-discovery') CERTIFICATES = tuple(SERVER / 'devstate' / kind / leaf for kind in ('pki', 'api-pki') for leaf in ('ca.pem', 'server.pem')) PROFILE = 'rmm.server-time-broker.bootstrap.v1' -QUALITY_PHASE = 'probe-peer-acceptance-v1' -QUALITY_CONTROLLER_SHA = 'ca89eac44d6b1e8bbbb14cca58ecabb02fd05d59292b77f703997fad0c29e3c8' -QUALITY_RESULT_SHA = None # Root must bind an independently reviewed actual native PASS first. -GROUP_FAILURE_SHA = '4977876b935bed8903ce4c880a0d9c77c49cd2c7110551fbf854baeccbe64ea7' +GENERATION_CASE_ID = 'c9a94f94-eecd-4c66-933d-c45c1a79c7a8' +GENERATION_CASE = CASE.parent / GENERATION_CASE_ID +QUALITY_PHASE = 'probe-native-source-v1' +QUALITY_CONTROLLER_SHA = 'c15f4dad9aeb51270fbee7ba28a545cfe9f6a879d0bc226cf5ddda9036a5a2b6' +QUALITY_RESULT_SHA = 'ab8a6511517c6e3c01db2351ccdc5c48c73f34112c9ac863d0ea64de46665933' GROUPADD_SHA = '468289aa24d8e9bacb1f21d315e59dc49febec5f120eb7a01b44fe6e98700ed0' -OLD_QUALITY_ORIGIN = { - 'original_group_acceptance_controller_sha256': 'd04989ccf6d3e7b379a1b02f5fd3ce2545a3563fbce1368f33102f58a36f2dcf', - 'original_group_acceptance_result_sha256': '96b714e2e43aa13073317c310b213863a02f26dbf2e6c975dc0801ef621eccd5', - 'original_group_acceptance_log_sha256': 'f80644630b09f50fdc731418dbe4f17fff32622910b3efd346a0369b75e985ef', - 'original_group_acceptance_receipt_sha256': '6923cc1893619f67ae8677b84f9cfea6d0edd554120e9139d843115e52aa7643', - 'original_dac_diagnostic_receipt_sha256': 'd999e5260cab3457a7a66603fdb0288615443628e5a28f31df9c1cecd3401ef5', -} -PEER_ORIGIN = { - 'peer_namespace_controller_sha256': '2f1dafece1e5cd1b9be11078edee5f67fbdaef013defa10c527367b42dce9265', - 'peer_namespace_result_sha256': 'cb1665cb14086d3ba79089a2eb9e01a532dd779bdcf577eafca0e343b5cc6a8b', - 'peer_namespace_local_profile_sha256': '27e3708a34988fb778cbc8cfd892e0f222b8caf927034e472f391aab65349394', - 'peer_namespace_receipt_sha256': '1dc76b5a9673f9e08e59f91f05d586cb9335ffd0a33e697d5170823a6f053619', - 'peer_namespace_read_receipt_sha256': '129584f296b53614e10a9e5eac2bab0a1e70b1c51f7fd70eb31bdf907ce767b3', - 'original_dac_acceptance_controller_sha256': '1b79a4ab8d587338e43330db0fc73ff2e199dc61f1172da7cc3fc93d3538d2ac', - 'original_dac_acceptance_result_sha256': '5f8e0634e44c7caeab2020af5f5dd0d6e83249265d0ebd67f938f0797b551fca', - 'original_dac_acceptance_log_sha256': 'f80644630b09f50fdc731418dbe4f17fff32622910b3efd346a0369b75e985ef', - 'original_dac_acceptance_receipt_sha256': '553bc8580deb0e78d780b43c569f3827715a54a7b8629c51c705cf4e9ded7c61', -} -PEER_MAIN_SHA = '214e509af9ab9b713e89b09bf6440c4b4248e97c64d4b0d884d2f869d406e1e2' -PEER_CODE = Path('/var/lib/rmm-time-source-operators') / PEER_ORIGIN['peer_namespace_controller_sha256'] / 'peer_namespace_bootstrap.py' PKCS8 = bytes.fromhex('302e020100300506032b657004220420') SPKI = bytes.fromhex('302a300506032b6570032100') UNIT_RAW = b'''[Unit] @@ -138,6 +119,23 @@ def protected_code(): 'reviewed_pin_controller_unchanged') +def protected_generation(pin): + require(type(QUALITY_CONTROLLER_SHA) is str and re.fullmatch('[0-9a-f]{64}', QUALITY_CONTROLLER_SHA), + 'reviewed_new_generation_controller_not_bound') + path = Path('/var/lib/rmm-time-source-operators') / QUALITY_CONTROLLER_SHA / 'new_generation_probe.py' + record = pin.read_file(path, 128 * 1024) + require(sha(record[0]) == QUALITY_CONTROLLER_SHA, 'exact_reviewed_new_generation_controller') + module = importlib.util.module_from_spec(importlib.util.spec_from_loader('rmm_new_generation_guard', loader=None)) + module.__file__ = str(path) + exec(compile(record[0], str(path), 'exec'), module.__dict__) + require(module.CASE_ID == GENERATION_CASE_ID and module.QUALITY_PHASE == QUALITY_PHASE, + 'fixed_new_generation_case_and_quality_phase') + original = module.SharedGenerationProof(pin) + def guard(): + require(pin.read_file(path, 128 * 1024) == record, 'reviewed_new_generation_controller_unchanged') + return original, guard + + def command(pin, path, args, data=None): # Fixed public tools only. Private DER is stdin, never argv/environment/file. parent = pin.directory(path.parent) @@ -254,124 +252,19 @@ def forbidden_keys(pin, original): return sorted(keys), {'job_public_key_sha256': sha(bytes.fromhex(job['public_key_hex'])), 'certificates': certificates} -def quality_proof(pin, original, pin_result_raw, pin_result): - require(re.fullmatch('[0-9a-f]{64}', QUALITY_CONTROLLER_SHA), 'reviewed_quality_controller_not_bound') +def quality_proof(pin, original): require(type(QUALITY_RESULT_SHA) is str and re.fullmatch('[0-9a-f]{64}', QUALITY_RESULT_SHA), - 'actual_peer_quality_pass_not_bound') - phase = CASE / QUALITY_PHASE - require(not (phase / 'failure.json').exists(), 'original_quality_probe_failed') - raw, proof = pin.read_file(phase / 'result.json', 16384) - require(sha(raw) == QUALITY_RESULT_SHA, 'exact_actual_peer_quality_pass') - result = pin.parsed(raw) - artifact = original.artifacts['examples/operator_probe'][1] - old_probe, _ = pin.read_file(CASE / 'probe/result.json', 16384) - binding = {'profile': 'rmm.server-time-source.peer-acceptance.v1', 'original_case': CASE_ID, - 'phase': QUALITY_PHASE, 'unit': 'rmm-time-source-probe-peer-acceptance-' + CASE_ID + '.service', - 'controller_sha256': QUALITY_CONTROLLER_SHA, 'operator_sha256': pin.OPERATOR_SHA, - 'pin_controller_sha256': PIN_SHA, 'public_pin_sha256': pin_result['public_pin_sha256'], - 'source_tar_sha256': original.source_sha, 'manifest_sha256': original.manifest_sha, - 'artifact': artifact, 'original_group_receipt_sha256': GROUP_FAILURE_SHA, - 'original_probe_result_sha256': sha(old_probe), 'pin_result_sha256': sha(pin_result_raw), **OLD_QUALITY_ORIGIN, **PEER_ORIGIN} - extra = {'before_witness', 'after_witness', 'exit_code', 'sample', 'probe_log_sha256', 'source_quality_qualified', - 'runtime_boot_pin_source_preserved', 'clock_authority', 'signed_attestation', 'signer_created', 'broker_started', 'http_deployed'} - require(set(result) == set(binding) | extra and all(result[key] == value for key, value in binding.items()) and - result['source_quality_qualified'] is True and type(result['exit_code']) is int and result['exit_code'] == 0 and - result['runtime_boot_pin_source_preserved'] is True and all(result[key] is False for key in - ('clock_authority', 'signed_attestation', 'signer_created', 'broker_started', 'http_deployed')), - 'original_quality_result_binding') - old_group, old_group_state = pin.read_file(CASE / 'probe-group-acceptance-v1/result.json', 16384) - old_log, old_log_state = pin.read_file(CASE / 'probe-group-acceptance-v1/probe.log', 16384) - require(sha(old_group) == OLD_QUALITY_ORIGIN['original_group_acceptance_result_sha256'] and - sha(old_log) == OLD_QUALITY_ORIGIN['original_group_acceptance_log_sha256'], 'unchanged_original_failed_group_acceptance') - witness_records = {CASE / 'probe-group-acceptance-v1/result.json': (old_group, old_group_state), - CASE / 'probe-group-acceptance-v1/probe.log': (old_log, old_log_state)} - for leaf, expected_sha in (('result.json', PEER_ORIGIN['original_dac_acceptance_result_sha256']), - ('probe.log', PEER_ORIGIN['original_dac_acceptance_log_sha256'])): - path = CASE / 'probe-dac-acceptance-v1' / leaf - record = pin.read_file(path, 16384) - require(sha(record[0]) == expected_sha, 'unchanged_original_failed_dac_acceptance') - witness_records[path] = record - namespace_path = CASE / 'peer-namespace-bootstrap-v1/result.json' - namespace_record = pin.read_file(namespace_path, 16384) - require(sha(namespace_record[0]) == PEER_ORIGIN['peer_namespace_result_sha256'], 'actual_peer_namespace_result') - witness_records[namespace_path] = namespace_record - witnesses = [] - for name in ('before', 'after'): - link = result[name + '_witness'] - require(set(link) == {'filename', 'sha256'} and link['filename'] == name + '.json', 'fixed_quality_witness_link') - data, state = pin.read_file(phase / link['filename'], 16384) - require(sha(data) == link['sha256'], 'original_quality_witness_hash') - witness = pin.parsed(data) - require(set(witness) == set(binding) | {'witness'} and all(witness[key] == value for key, value in binding.items()), - 'original_quality_witness_binding') - actual = witness['witness'] - require(set(actual) == {'observation', 'public_pin_sha256', 'public_pin_metadata', 'target_directories', 'peer_namespace'} and - actual['observation'] == original.expected and actual['public_pin_sha256'] == pin_result['public_pin_sha256'] and - actual['public_pin_metadata'] == pin_result['public_pin_metadata'], 'original_quality_source_pin_witness') - directories = {name: {key: value[key] for key in ('dev', 'ino', 'uid', 'gid', 'mode')} - for name, value in pin_result['targets'].items() if name != str(ETC / 'chrony-pin.json')} - require(actual['target_directories'] == directories, 'original_quality_directory_witness') - peer = actual['peer_namespace'] - require(type(peer) is dict and set(peer) == {'result_sha256', 'main_profile_sha256', 'local_profile_sha256', - 'main_profile_metadata', 'local_profile_metadata', 'parent_access_acl_hex', 'profile'} and - peer['result_sha256'] == PEER_ORIGIN['peer_namespace_result_sha256'] and - peer['main_profile_sha256'] == PEER_MAIN_SHA and - peer['local_profile_sha256'] == PEER_ORIGIN['peer_namespace_local_profile_sha256'] and - type(peer['profile']) is dict and set(peer['profile']) == {'chronyd_label', 'enforcing'} and - peer['profile']['chronyd_label'] == '/usr/sbin/chronyd (enforce)' and peer['profile']['enforcing'] is True, - 'exact_peer_namespace_quality_witness') - witnesses.append(actual) - witness_records[phase / link['filename']] = (data, state) - require(witnesses[0] == witnesses[1], 'original_quality_before_after_equal') - sample = result['sample'] - keys = {'profile', 'clock_authority', 'signed_attestation', 'captured_utc_ns', 'server_error_ns', 'source_sync_age_ns', - 'server_boot_id', 'captured_monotonic_ns', 'sampled_boottime_ns', 'kernel_state'} - require(type(sample) is dict and set(sample) == keys and sample['profile'] == 'rmm.native-source-quality.once.v1' and - sample['clock_authority'] is False and sample['signed_attestation'] is False and - sample['server_boot_id'] == original.expected['boot_id'] and - all(type(sample[key]) is int for key in ('captured_utc_ns', 'server_error_ns', 'source_sync_age_ns', - 'captured_monotonic_ns', 'sampled_boottime_ns', 'kernel_state')) and - 0 < sample['captured_utc_ns'] <= (1 << 63) - 1 and 0 <= sample['server_error_ns'] <= 500_000_000 and - 0 <= sample['source_sync_age_ns'] <= 3_600_000_000_000 and 0 <= sample['kernel_state'] <= 4 and - 0 < sample['captured_monotonic_ns'] <= (1 << 64) - 1 and - sample['captured_monotonic_ns'] <= sample['sampled_boottime_ns'] <= (1 << 64) - 1, 'actual_native_quality_sample_bounds') - log_raw, log_state = pin.read_file(phase / 'probe.log', 16384) - require(sha(log_raw) == result['probe_log_sha256'] and pin.parsed(log_raw) == sample, 'original_actual_quality_sample_log') - return ({phase / 'result.json': (raw, proof), phase / 'probe.log': (log_raw, log_state), **witness_records}, - witnesses[0]['peer_namespace']) - - -class PeerNamespaceProof: - """Only the fixed reviewed namespace's read-only ACL/MAC observations.""" - def __init__(self, pin, original, expected): - self.pin, self.original, self.expected = pin, original, expected - self.code = pin.read_file(PEER_CODE, 128 * 1024) - require(sha(self.code[0]) == PEER_ORIGIN['peer_namespace_controller_sha256'], 'reviewed_peer_namespace_controller') - module = importlib.util.module_from_spec(importlib.util.spec_from_loader('rmm_peer_namespace_guard', loader=None)) - module.__file__ = str(PEER_CODE) - exec(compile(self.code[0], str(PEER_CODE), 'exec'), module.__dict__) - self.namespace = module - require(module.MAIN_SHA == PEER_MAIN_SHA and sha(module.LOCAL_BYTES) == PEER_ORIGIN['peer_namespace_local_profile_sha256'] and - module.expected_acl().hex() == expected['parent_access_acl_hex'], 'fixed_peer_namespace_contract') - self.verify() - - def verify(self): - pin, namespace = self.pin, self.namespace - actual = self.original.fresh() - require(pin.read_file(PEER_CODE, 128 * 1024) == self.code, 'peer_namespace_controller_unchanged') - main, main_state = pin.read_file(namespace.MAIN, 65536, 0o644) - local, local_state = pin.read_file(namespace.LOCAL, 16384, 0o644) - require(sha(main) == PEER_MAIN_SHA and sha(local) == PEER_ORIGIN['peer_namespace_local_profile_sha256'] and - local == namespace.LOCAL_BYTES and main_state == self.expected['main_profile_metadata'] and - local_state == self.expected['local_profile_metadata'], 'actual_held_peer_profiles_unchanged') - parent = pin.directory(namespace.PARENT) - try: - require(namespace.acl(parent) == namespace.expected_acl() and - namespace.acl(parent, 'system.posix_acl_default') is None, 'actual_exact_peer_parent_acl') - finally: - os.close(parent) - require(namespace.profile_state(actual['daemon_pid']) == self.expected['profile'], 'actual_chronyd_profile_still_enforcing') - self.original.fresh() + 'actual_new_generation_quality_pass_not_bound') + # The fixed reviewed shared decoder checks the entire new-generation + # result/witness/sample contract, not an old successful build or CLI status. + records = original.quality_proof(QUALITY_RESULT_SHA) + result_path = GENERATION_CASE / QUALITY_PHASE / 'result.json' + require(type(records) is dict and result_path in records and + sha(records[result_path][0]) == QUALITY_RESULT_SHA, + 'actual_new_generation_quality_original_result') + for path, record in records.items(): + require(pin.read_file(path, 65536) == record, 'actual_new_generation_quality_records_unchanged') + return records # Closed system-manager load namespace, including control, attached and @@ -488,39 +381,45 @@ class Context: self.pin, self.pin_guard = pin, pin_guard self.retained_records = {} self.composition = None - operator, guard = pin.load_operator() - self.original = pin.Original(CASE, operator, guard) - require(self.original.artifacts['rmm-time-broker-linux'][1] == - {'bytes': BROKER_BYTES, 'sha256': BROKER_SHA, 'elf_machine': 183}, 'original_exact_broker_elf') - require(not (CASE / 'pin/failure.json').exists(), 'original_pin_failed') - self.pin_result = pin.read_file(CASE / 'pin/result.json') - result = pin.parsed(self.pin_result[0]) - require(result['profile'] == pin.PROFILE and result['case'] == CASE_ID and - result['operator_sha256'] == pin.OPERATOR_SHA and result['source_tar_sha256'] == self.original.source_sha and - result['manifest_sha256'] == self.original.manifest_sha and result['runtime_boot_chrony_preserved'] is True and - result['signer_created'] is False and result['services_started'] is False, - 'original_successful_public_pin') - self.public_pin_result = result - self.quality_records, peer_witness = quality_proof(pin, self.original, self.pin_result[0], result) - self.peer_proof = PeerNamespaceProof(pin, self.original, peer_witness) - self.forbidden, self.roles = forbidden_keys(pin, self.original) - self.fresh() + self.original = None + # Closed before loading a new source generation, public-role getter, + # entropy, phase directory, group or installation effect. + require(type(QUALITY_RESULT_SHA) is str and re.fullmatch('[0-9a-f]{64}', QUALITY_RESULT_SHA), + 'actual_new_generation_quality_pass_not_bound') + try: + self.original, self.generation_guard = protected_generation(pin) + require(self.original.artifacts['rmm-time-broker-linux'][1] == + {'bytes': BROKER_BYTES, 'sha256': BROKER_SHA, 'elf_machine': 183}, 'original_exact_broker_elf') + self.quality_records = quality_proof(pin, self.original) + self.original.namespace_verify() + self.forbidden, self.roles = forbidden_keys(pin, self.original) + self.fresh() + except BaseException: + self.close() + raise + + def close(self): + if self.composition is not None: + self.composition.close() + self.composition = None + if self.original is not None: + self.original.close() + self.original = None def fresh(self): self.pin_guard() + self.generation_guard() current = self.original.fresh() - self.peer_proof.verify() + self.original.namespace_verify() for path, record in {**self.quality_records, **self.retained_records}.items(): - require(self.pin.read_file(path, 16384) == record, 'original_actual_quality_proof_unchanged') - require(self.pin.read_file(CASE / 'pin/result.json') == self.pin_result, 'original_pin_result_unchanged') + require(self.pin.read_file(path, 65536) == record, 'original_actual_quality_proof_unchanged') raw, proof = self.pin.read_file(ETC / 'chrony-pin.json', 8192) - require(raw == encoded(current) and sha(raw) == self.public_pin_result['public_pin_sha256'] and - proof == self.public_pin_result['public_pin_metadata'], 'original_chrony_pin_unchanged') + require(raw == self.original.public_pin_raw == encoded(current) and + proof == self.original.public_pin_metadata, 'new_generation_chrony_pin_unchanged') for path in (ETC, Path('/run/rmm-time-source'), Path('/run/rmm-time-source/clients')): - before = self.public_pin_result['targets'][str(path)] fd = self.pin.directory(path) try: - require(self.pin.stable_directory(os.fstat(fd)) == {key: before[key] for key in ('dev', 'ino', 'uid', 'gid', 'mode')}, + require(self.pin.stable_directory(os.fstat(fd)) == self.original.target_directories[str(path)], 'original_runtime_directory_identity') finally: os.close(fd) @@ -686,10 +585,16 @@ def phase(name, action, pin, pin_guard): context.fresh() pin.exclusive(phase_fd, 'intent.json', encoded({'profile': PROFILE, 'case': CASE_ID, 'phase': name, 'controller_sha256': sha(Path(__file__).read_bytes()), 'pin_controller_sha256': PIN_SHA, - 'source_tar_sha256': context.original.source_sha, 'manifest_sha256': context.original.manifest_sha})) + 'source_tar_sha256': context.original.source_sha, 'manifest_sha256': context.original.manifest_sha, + 'generation_case': GENERATION_CASE_ID, 'generation_controller_sha256': QUALITY_CONTROLLER_SHA, + 'quality_result_sha256': QUALITY_RESULT_SHA, + 'chrony_public_pin_sha256': sha(context.original.public_pin_raw)})) result = action(context) context.fresh() - receipt = {'profile': PROFILE, 'case': CASE_ID, 'phase': name, 'result': result} + receipt = {'profile': PROFILE, 'case': CASE_ID, 'phase': name, 'result': result, + 'generation_case': GENERATION_CASE_ID, 'generation_controller_sha256': QUALITY_CONTROLLER_SHA, + 'quality_result_sha256': QUALITY_RESULT_SHA, + 'chrony_public_pin_sha256': sha(context.original.public_pin_raw)} pin.exclusive(phase_fd, 'result.json', encoded(receipt)) print(encoded(receipt).decode('ascii'), end='') except Exception as error: @@ -701,8 +606,8 @@ def phase(name, action, pin, pin_guard): print(encoded(failure).decode('ascii'), end='') raise SystemExit(1) finally: - if context is not None and context.composition is not None: - context.composition.close() + if context is not None: + context.close() if phase_fd >= 0: os.close(phase_fd) os.close(case_fd) diff --git a/docs/server-time-broker-bootstrap.md b/docs/server-time-broker-bootstrap.md index 954ad8a..0096b49 100644 --- a/docs/server-time-broker-bootstrap.md +++ b/docs/server-time-broker-bootstrap.md @@ -10,26 +10,40 @@ Der feste Originalfall ist `5b358997-3abc-43db-945f-f41855b4e3c0`. Der unveränderte Pinbootstrap `fac85dd…` wird ausschließlich von `/var/lib/rmm-time-source-operators//pin_bootstrap.py` geladen: Root:Root0600, ein regulärer Link, geschützte Ancestry und exakter SHA256. -Seine tatsächlichen Original-Preflight-/Build-/Quellen-/Boot-/Runtime- und -Chrony-/Pinbindungen bleiben Pflicht. Der Broker muss genau das erfolgreiche +Seine tatsächlichen Original-Preflight-/Build-/Quellen-/Boot-/Runtimebelege +bleiben unverändert Pflicht. Nach dem ausdrücklich genehmigten Chronyneustart +werden die alte Prozessgeneration und ihr alter Pin ausschließlich historisch +geprüft; der neue gemeinsame Generationbeleg bindet den aktuellen Prozess und +den tatsächlich ersetzten öffentlichen Pin. Kein Aufruf oder Umgehen des alten +`pin.Original`-Konstruktors ist hierfür zulässig. Der Broker muss genau das erfolgreiche ARM64-ELF1067136Bytes/SHA256 `5d8d786925c060eb042f0a592453f11970c32c4287fa4c9464f6f6a6e38cb201` sein. Alte gescheiterte Probe-/Bootstrapversuche werden nicht umgeschrieben. -Vor jeder der drei Phasen ist zusätzlich das tatsächliche erfolgreiche -`probe-peer-acceptance-v1/result.json` desselben Originalfalls nötig. -Der Gate bindet den separat geprüften Probecontroller, vollständige -Vorher-/Nachher-Zeugen samt ihren gespeicherten Bytes/Hashes, Sources, Artefakt, -öffentlichen Pin, ursprüngliche Fehler-/Pinbelege und identische Boot-ID. -Das tatsächliche Sample muss strikt Fehler≤500ms, Syncalter≤1h, Kernelstate0..4 -und alle unveränderten Samplefelder erfüllen. Eine Fixture, Callerbool oder -Dateipräsenz allein qualifiziert nichts. Die Qualitätsprobe muss erfolgen, -bevor die neue Supplementary-Gruppe angelegt wird. Die neue DAC-Probe belegt -das separat diagnostizierte Zugriffsprofil; die frühere GROUP-Probe mit Exit1 -bleibt fehlgeschlagen und ihre Originalbytes/-Hashes bleiben gebunden. -Eine historische erfolgreiche Probe wird nicht als aktuelle Zeitautorität -wiederverwendet; der laufende Broker muss später vor jeder Signatur selbst -frisch messen. +Vor jeder der drei Phasen ist zusätzlich ein tatsächlicher erfolgreicher +`probe-native-source-v1/result.json` im neuen Generationsfall +`c9a94f94-eecd-4c66-933d-c45c1a79c7a8` nötig, Profil +`rmm.server-time-source.native-generation-acceptance.v1`. Der gemeinsame, +Rootgeschützte und exakt hashgebundene `SharedGenerationProof` liest den +historischen5b-Build ausschließlich als erhaltende Quellen-/ELFprovenanz. Er +verlangt zusätzlich die tatsächlichen c9-Neustart-/Pin-CAS-Belege und hält den +aktuellen Prozess-/Socket-/Konfigurations-/Namespace-/Bootkontext unabhängig. +Sein strikter gemeinsamer Qualitätsdecoder prüft die neuen vollständigen +Result-/Witness-/Samplebelege. Frühere GROUP-/DAC-/ca89-Fehlschläge bleiben +unverändert fehlgeschlagen; keiner kann dieses neue Gate erfüllen. + +Der anfänglich geschlossene `QUALITY_RESULT_SHA=None`-Gate ist jetzt durch +ein enges Einzeilendelta ausschließlich an das tatsächlich erfolgreiche neue +Resultat `ab8a6511517c6e3c01db2351ccdc5c48c73f34112c9ac863d0ea64de46665933` +gebunden. Root hat Ausführung und einen separaten Original-Read nachgewiesen; +die genauen Belege stehen am Ende dieses Dokuments. Ein erfolgreicher Restart +oder CLI-Tracking allein hätte diesen Gate nicht erfüllt. Dies installiert +keinen Signer oder Broker und startet weder Dienst noch HTTP-Endpunkt. +Eine historische erfolgreiche Probe wird später nicht als aktuelle +Zeitautorität wiederverwendet: der laufende Broker misst vor jeder Signatur +selbst frisch. Schlüssel-/Gruppen-/Installationsphasen verbleiben create-only +im ursprünglichen5b-Fall und speichern die exakten c9-/Controller-/Qualitäts-/ +öffentlichen-Pinlinks zusätzlich in Intent und Resultat. Auf dem Server ausschließlich isoliert starten: @@ -117,7 +131,7 @@ Das notwendige Reader-Token bleibt ausschließlich Root:Root0600. Keine Root-Eigentümerschaft der öffentlichen PKI wird erfunden oder geändert. -Der Installationsgate ist ausschließlich an die neue DAC-Probe gebunden, +Der damalige historische Installationsgate war ausschließlich an die DAC-Probe gebunden, einschließlich ihrer fünf zusätzlichen Herkunftshashes. Das alte GROUP-Probe- Resultat und Log werden weiterhin bytegleich gelesen und nie als erfolgreich umgedeutet. Fehlender oder nicht erfolgreicher DAC-Nachweis verweigert bereits @@ -201,7 +215,7 @@ unverändert. Der tatsächliche native Qualitätsgate bleibt weiterhin geschloss keine Vorratsfreigabe oder Zielaktion folgt aus diesem Reviewfix. -## Separater Peer-Qualifier: weiterhin keine operative Freigabe +## Historischer separater Peer-Qualifier: keine operative Freigabe Der vorbereitete Gate verwendet jetzt ausschließlich `probe-peer-acceptance-v1/result.json`, Profil @@ -251,3 +265,89 @@ Providertransport und seine tatsächlichen Abnahmen bleiben separate Gates. Dies ändert keinen alten Fehler in einen Erfolg. Der Brokergate bleibt `QUALITY_RESULT_SHA=None`; weder Schlüssel noch Gruppe oder Installation sind damit freigegeben. + + +## Historischer Quellencheckpoint: zunächst geschlossener Brokeradapter + +Root hat den vom User ausdrücklich erlaubten einmaligen Chronyneustart und +öffentlichen Pin-CAS tatsächlich nachgewiesen. Generationsresultat SHA256 +`d648daadc43de90cda977ce60615b8e47072b785aa9fbfaea37ef8b58be6c9d4` +ist ein Restart-/Identitätsbeleg, keine native Sourcequalität. Der neue aktuelle +Daemon ist PID2519215/Birth17718075, weiterhin UID/GID989 mit demselben geprüften +Image. Der neue öffentliche Pin umfasst195Bytes. Der alte Peerqualifier ca89 +bleibt `source_quality_qualified=false`. + +Der Brokeradapter lädt ausschließlich den separat eingefrorenen gemeinsamen +`new_generation_probe.py` aus seinem Content-addressed Root0600-Operatorpfad. +Kein `pin.Original()`-Aufruf, keine Änderung alter `expected`-Werte und kein +Fallback auf alte PIDs. `SharedGenerationProof` hält historische Originale und +aktuellen neuen Pin; vor jedem Write werden seine Originalrecords, aktuelle +Prozess-/Namespacezeugen und die gebundenen Qualitätsrecords erneut geprüft. +Die drei eigenen Verzeichnisse behalten dev/ino/uid/gid/mode und ACLs; spätere +legitime eigene Dateierzeugung wird nicht durch erfundene Verzeichnismtime- +Gleichheit verhindert. Fremde Objekte werden weiterhin nicht übernommen. +Alle gehaltenen Proof-FDs werden beim regulären Ende und Konstruktorfehler +explizit geschlossen. Schlüsseltrennung, feste Tools, Crypto-/Private-Ausgabe- +Grenzen, Unitkomposition und create-only Wirkungsphasen bleiben unverändert. + +Der Quelladapter und isolierte Deltaguards ersetzen sämtliche externe Autorität +durch Fixtures. Ihre Positivfälle sind kein tatsächlicher Qualitätsnachweis. +Es wurden durch diesen Adapter weder Zielzugriffe noch Schlüssel-/Gruppen-/ +Dienstwirkungen oder weitere Updateränderungen ausgeführt. + +Tatsächlich lokal ausgeführte Adapter-Deltaguards: drei Gruppen bestanden. +Der initiale `None`-Gate verweigerte vor jedem ersetzten externen Zugriff; +der gemeinsame Decoder erhielt exakt den verlangten Resulthash, fehlender +Resultpfad oder veränderte gespeicherte Bytes verweigerten; der Context prüfte +neuen Pin/Namespace erneut und schloss gehaltene Proofs auch nach Fehler im +Konstruktor. Alle externen Autoritäten/Getters waren ersetzt, ausschließlich +ein eigener temporärer Verzeichnis-FD wurde verwendet. Fünfzehn bestehende +Crypto-/Role-/Unitcomposition-/Create-only-/Readdefinitionen und sechs feste +Konstantenausdrücke wurden bytegleich gegen Controller31f2 nachgewiesen. +Der erste reine Vergleichshelfer versuchte `ast.literal_eval` auf +`bytes.fromhex(...)` und brach ab; der korrigierte AST-Ausdrucksvergleich +bestand, ohne Änderung der Produktquelle oder einer Prüfungsausnahme. + + +Gemeinsamer eingefrorener Generation-/Qualifiercontroller: SHA256 +`c15f4dad9aeb51270fbee7ba28a545cfe9f6a879d0bc226cf5ddda9036a5a2b6`, +36.967Bytes, fester Hostname `new_generation_probe.py` im gleichnamigen +SHA256-Elternpfad. Der Broker bindet genau diese Quelle; ihr gemeinsamer +Qualitätsdecoder hält vier Originalrecords (Resultat, Log, Vorher/Nachher). +Die separate Sourcequalifikation des Controllers ist kein tatsächlicher +Probe-PASS. Beim damaligen Quellenfreeze blieb `QUALITY_RESULT_SHA=None`; +der anschließende tatsächliche PASS und sein enges Hashdelta folgen unten. + + +## Tatsächlicher neuer Qualitätsnachweis und exakte Resultbindung + +Root führte die native Probe im c9-Generationsfall tatsächlich aus: +Originalaufruf `a8c61ad4-5ced-44dd-a120-1ef5cd2bb68b`, Receipt SHA256 +`1aab3af930648aed260c4c66a1c3ff068656cae016fcc301f052880926f99c93`. +Separater ausschließlich lesender Originalaufruf +`de6273d1-3ae5-4f02-b759-e13fbf8116e9`, Receipt SHA256 +`7005ef54759412cd0d95e558ceebbf524a55c04bf6641c8241161e0d5e81fbf3`. +Das exakte Resultat besitzt SHA256 +`ab8a6511517c6e3c01db2351ccdc5c48c73f34112c9ac863d0ea64de46665933`. +Exit0, `source_quality_qualified=true`, unveränderte Vorher-/Nachherzeugen, +Kernelstate0, tatsächlicher Gesamtfehler50.833.923ns und Syncalter43.596.197.206ns. +Diese Werte sind der einzelne gemessene Probenstand, keine fortdauernde +Qualitätszusage oder bereits signierte Zeitattestierung. + +Ausschließlich die eine Controllerzeile `QUALITY_RESULT_SHA` wurde von `None` +auf genau diesen Hash gesetzt; Sharedcontrollerc15f, Wirkungs-/Crypto-/Role-/ +Unitcompositionquellen und sämtliche Schutzbedingungen bleiben bytegleich. +Die drei alten GROUP-/DAC-/ca89-Fehler bleiben unverändert fehlgeschlagen. +Ein lokaler Decoder-Gegencheck verwendet die vier tatsächlich gespeicherten +Originalrecords Resultat/Log/Vorher/Nachher aus dem separaten Root-Read, +prüft ihre exakten Byteshashes und lässt sie durch die unveränderte gemeinsame +`SharedGenerationProof.quality_proof` laufen. Live-Prozess-/Datei-FDautorität +wird dabei ausdrücklich durch den gespeicherten Root-Read ersetzt: kein neuer +Zielzugriff und kein Ersatz der tatsächlichen Root-Ausführung oder Nachlese. + +Dieser Quellenschritt erzeugt keine Seeds, Schlüsseldateien, Gruppe10001, +Binary oder Unit und startet keinen Broker, HTTP oder Windows-Clockgate. +Root muss Host-key, Host-group und Host-install weiterhin getrennt reviewen +und selbst ausführen. Der spätere laufende Broker muss vor jeder Signatur eine +neue native Quelle messen; diese Probe ist kein wiederverwendbarer Zeitgrant. +WebUI-Jobs und sämtliche RMM-Genehmigungsgrenzen bleiben unverändert.