Bind broker provisioning to proven current time source generation
Rust development slice / linux (push) Failing after 7s

This commit is contained in:
2026-11-15 12:15:54 +01:00
parent 4647bd5d4d
commit 731f944747
2 changed files with 192 additions and 187 deletions
+74 -169
View File
@@ -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)
+118 -18
View File
@@ -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/<vollerSHA>/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.