From be57d98955c086fe5b7e18fb7996144ca311ac9e Mon Sep 17 00:00:00 2001 From: Kevin Janssen Date: Sun, 15 Nov 2026 11:42:32 +0100 Subject: [PATCH] Prepare reviewed Chrony generation change with passing read-only server preflight --- ...time_source_chrony_generation_bootstrap.py | 584 ++++++++++++++++++ docs/handover.md | 6 + ...time-source-chrony-generation-bootstrap.md | 129 ++++ 3 files changed, 719 insertions(+) create mode 100644 deploy/server_time_source_chrony_generation_bootstrap.py create mode 100644 docs/server-time-source-chrony-generation-bootstrap.md diff --git a/deploy/server_time_source_chrony_generation_bootstrap.py b/deploy/server_time_source_chrony_generation_bootstrap.py new file mode 100644 index 0000000..233c2be --- /dev/null +++ b/deploy/server_time_source_chrony_generation_bootstrap.py @@ -0,0 +1,584 @@ +#!/usr/bin/env python3 +"""Fixed one-time Chrony restart/public-pin CAS; requires explicit prior user approval. + +Source-only preparation does not authorize a target call. host-preflight and +host-read never restart or write. Lost reply/failure permits original read only. +""" +import argparse +import ctypes +import errno +import fcntl +import hashlib +import importlib.util +import json +import math +import os +from pathlib import Path +import re +import select +import stat +import struct +import sys +import time + +PROFILE = 'rmm.server-time-source.chrony-generation-bootstrap.v1' +CASE = 'c9a94f94-eecd-4c66-933d-c45c1a79c7a8' +BASE = Path('/var/lib/rmm-time-source-bootstrap') / CASE +ORIGINAL = Path('/var/lib/rmm-time-source-bootstrap/5b358997-3abc-43db-945f-f41855b4e3c0') +PIN_CONTROLLER_SHA = 'fac85dd0399009af36f625232daa5b67ab7fda391dbf95229d4237c307b142ca' +PIN_CONTROLLER = Path('/var/lib/rmm-time-source-operators') / PIN_CONTROLLER_SHA / 'pin_bootstrap.py' +OLD_PIN_SHA = '203f63f150026d345614ca53e641f248397166fbdeb1f28318fc5d7763317e0a' +OLD_PEER_RESULT_SHA = '71f212c5886b786f98d3dbe39f8a0adf76769e4f66ee516476db7df31cda413c' +CONFIG_RECEIPT_SHA = '7d5c7566a054ce353733155fbc2b98ef2a4d3f6d758bb85bd0e3ffd31bdeb22e' +CONFIG = { + '/etc/chrony/chrony.conf': (1622, '3d3bb53ddee1a78de319508913c08b34891b66e5e168356f2d9ca217ab85ba68'), + '/etc/chrony/conf.d/ubuntu-nts.conf': (389, '4355f44d20dc1bda2db04ea005910c7742cd244aa6f688a0da75aca3544c157a'), + '/etc/chrony/sources.d/ubuntu-ntp-pools.sources': (1553, 'e5eb19e7e5dd56164698bfd44b24a76d40f517de84245726b953c4a681c8f095'), + '/etc/default/chrony': (412, 'e93b5d3ecd73651a49e1e7c7984e026cd09271554cce23b851022aece3aa1547'), + '/usr/lib/systemd/system/chrony.service': (2003, 'a13aa0e542b57cc75a0b87f2b15785f53e4e86f03dc3db7b572ea056f31c2218'), +} +INCLUDE_DIRS = {'/etc/chrony/conf.d': ['README', 'ubuntu-nts.conf'], + '/etc/chrony/sources.d': ['README', 'ubuntu-ntp-pools.sources'], '/run/chrony-dhcp': None} +INCLUDE_RECEIPT_SHA = 'ee557a17e7188dcf2211cde5df575ad3c101a6412f564eb53dc385a77262c22d' +STARTER_SHA = '48ae26b9a01b359ac6a743c074265e4b19a3ed99bbc4c46953850c75edde8e1c' +DBUS_RECEIPT_SHA = '6ca943b071bb85c8c3f84ace00135e97acea48c6b0e0fcce3550b253aa67b092' +STARTER = '/usr/lib/systemd/scripts/chronyd-starter.sh' +EMPTY_EXEC = ('ExecStartPre', 'ExecStartPost', 'ExecStop', 'ExecStopPost') +MAIN = Path('/etc/apparmor.d/usr.sbin.chronyd') +MAIN_SHA = '214e509af9ab9b713e89b09bf6440c4b4248e97c64d4b0d884d2f869d406e1e2' +LOCAL = Path('/etc/apparmor.d/local/usr.sbin.chronyd') +LOCAL_SHA = '27e3708a34988fb778cbc8cfd892e0f222b8caf927034e472f391aab65349394' +POLICY = Path('/sys/kernel/security/apparmor/policy/profiles/usr.sbin.chronyd.159') +POLICY_SHA = 'a0dd0b80f5e074b3cf0350a618ca98855a3076c7e869d2a80d209b57b3b220fa' +PUBLIC_PIN = Path('/etc/rmm-time-source/chrony-pin.json') +TEMP_PIN = '.chrony-pin-generation-' + CASE + '.new' +ABSENT = tuple(Path(value) for value in ('/etc/rmm-time-source/signer.json', + '/etc/rmm-time-source/time-public-key.json', '/usr/local/libexec/rmm-time-broker', + '/etc/systemd/system/rmm-time-broker.service')) +RECORDS = ('intent.json', 'before.json', 'old-public-pin.bin', 'restart-intent.json', + 'restart-exit.json', 'after-restart.json', 'readiness.json', 'cas-intent.json', 'new-public-pin.bin', + 'after.json', 'result.json', 'failure.json', 'restart.log') +RECORDS += tuple('readiness-' + str(index).zfill(2) + '.json' for index in range(1, 26)) +READINESS_SECONDS = 25 + + +class GuardDenied(RuntimeError): + pass + + +def require(value, reason): + if not value: + raise GuardDenied(reason) + + +def failure_tag(error): + if isinstance(error, GuardDenied) and len(error.args) == 1 and type(error.args[0]) is str: + tag = error.args[0] + if len(tag) <= 128 and re.fullmatch(r'[a-z0-9_]+', tag): + return tag + return 'unexpected_generation_exception' + + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + + +def load_pin_controller(): + fd = os.open('/', os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW) + try: + for part in PIN_CONTROLLER.parent.parts[1:]: + info = os.fstat(fd) + require(info.st_uid == 0 and info.st_mode & 0o022 == 0, 'protected_controller_ancestry') + next_fd = os.open(part, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW, dir_fd=fd) + os.close(fd) + fd = next_fd + info = os.fstat(fd) + require(info.st_uid == 0 and info.st_mode & 0o022 == 0, 'protected_controller_parent') + file_fd = os.open(PIN_CONTROLLER.name, os.O_RDONLY | os.O_NOFOLLOW, dir_fd=fd) + with os.fdopen(file_fd, 'rb') as stream: + before = os.fstat(stream.fileno()) + require(stat.S_ISREG(before.st_mode) and before.st_uid == before.st_gid == 0 and + before.st_nlink == 1 and stat.S_IMODE(before.st_mode) == 0o600 and + before.st_size <= 128 * 1024, 'reviewed_root_controller_file') + raw = stream.read(128 * 1024 + 1) + stable = lambda s: tuple(getattr(s, 'st_' + k) for k in + ('dev', 'ino', 'uid', 'gid', 'mode', 'nlink', 'size', 'mtime_ns', 'ctime_ns')) + require(stable(before) == stable(os.fstat(stream.fileno())) == + stable(os.stat(PIN_CONTROLLER.name, dir_fd=fd, follow_symlinks=False)) and + len(raw) == before.st_size and sha(raw) == PIN_CONTROLLER_SHA, 'exact_pin_controller_bytes') + finally: + os.close(fd) + pin = importlib.util.module_from_spec(importlib.util.spec_from_loader('rmm_peer_pin_guard', loader=None)) + pin.__file__ = str(PIN_CONTROLLER) + exec(compile(raw, str(PIN_CONTROLLER), 'exec'), pin.__dict__) + held = pin.read_file(PIN_CONTROLLER, 128 * 1024) + require(held[0] == raw, 'same_loaded_pin_controller') + return pin, lambda: require(pin.read_file(PIN_CONTROLLER, 128 * 1024) == held, 'pin_controller_unchanged') + +def bounded_kernel(path, maximum=262144): + # Fixed securityfs/proc paths, never caller-controlled or returned as bytes. + with path.open('rb') as stream: + raw = stream.read(maximum + 1) + require(len(raw) <= maximum, 'bounded_kernel_policy_metadata') + return raw + + +def create_record(parent, name, raw): + require(name in RECORDS and len(raw) <= 65536 and raw.isascii(), 'closed_bounded_generation_record') + 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_generation_record') + view = view[count:] + os.fsync(fd) + finally: + os.close(fd) + os.fsync(parent) + + +def acl(fd, name): + try: + value = os.getxattr(fd, name) + require(len(value) <= 256, 'bounded_namespace_acl') + return value + except OSError as error: + require(error.errno == errno.ENODATA, 'acl_exact_absence_or_value') + return None + + +def include_directories(pin): + directories = {} + for name, expected in INCLUDE_DIRS.items(): + if expected is None: + # The reviewed DHCP directory is absent, not an empty directory. + # Hold its protected parent and reject every new leaf, including a + # symlink. Do not create or silently adopt an existing namespace. + path = Path(name) + parent = pin.directory(path.parent) + try: + before = pin.stable_directory(os.fstat(parent)) + try: + os.stat(path.name, dir_fd=parent, follow_symlinks=False) + except FileNotFoundError: + pass + else: + raise GuardDenied('reviewed_dhcp_namespace_must_remain_absent') + require(pin.stable_directory(os.fstat(parent)) == before, + 'same_protected_absent_dhcp_parent') + directories[name] = dict(present=False, parent=before) + finally: + os.close(parent) + continue + fd = pin.directory(Path(name)) + try: + require(sorted(os.listdir(fd)) == expected, 'closed_reviewed_chrony_include_directory') + # Chrony loads *.conf / *.sources; README is a package document, + # not another configuration file. Read only its protected metadata. + readme = os.stat('README', dir_fd=fd, follow_symlinks=False) + require(stat.S_ISREG(readme.st_mode) and readme.st_uid == readme.st_gid == 0 + and readme.st_nlink == 1 and readme.st_mode & 0o022 == 0, + 'ignored_readme_is_protected_regular_document') + directories[name] = dict(present=True, metadata=pin.stable_directory(os.fstat(fd)), + ignored_readme_metadata=pin.identity(readme)) + finally: + os.close(fd) + return directories + + +def typed_commands(pin, operator): + commands = {} + for name in EMPTY_EXEC + ('ExecStartEx',): + raw = operator.run(['/usr/bin/busctl', '--system', '--json=short', 'get-property', + 'org.freedesktop.systemd1', '/org/freedesktop/systemd1/unit/chrony_2eservice', + 'org.freedesktop.systemd1.Service', name], timeout=3, limit=8192) + value = pin.parsed(raw) + require(type(value) is dict and set(value) == {'type', 'data'}, 'typed_dbus_command_property_shape') + if name in EMPTY_EXEC: + require(value == {'type': 'a(sasbttttuii)', 'data': []}, 'typed_dbus_exec_list_must_be_empty') + commands[name] = value + continue + rows = value['data'] + require(value['type'] == 'a(sasasttttuii)' and type(rows) is list and len(rows) == 1 + and type(rows[0]) is list and len(rows[0]) == 10, 'typed_dbus_one_exec_start_ex') + row = rows[0] + require(row[:3] == [STARTER, [STARTER, '-n', '$DAEMON_OPTS'], ['no-setuid']], + 'typed_exact_exec_start_path_arguments_no_setuid_flag') + require(all(type(value) is int and 0 <= value < 2 ** 64 for value in row[3:7]) + and type(row[7]) is int and 0 <= row[7] < 2 ** 32 + and all(type(value) is int and -(2 ** 31) <= value < 2 ** 31 for value in row[8:]), + 'typed_exec_start_runtime_fields') + # Timestamps, PID and exit status are runtime fields. The actual process + # generation is bound independently by the complete ecb observation. + commands[name] = dict(type=value['type'], path=row[0], argv=row[1], flags=row[2]) + return commands + + +def configuration(pin, operator): + files = {} + for name, (size, expected) in CONFIG.items(): + raw, metadata = pin.read_file(Path(name), 65536, 0o644) + require(len(raw) == size and sha(raw) == expected, 'exact_reviewed_public_configuration') + files[name] = dict(sha256=expected, metadata=metadata) + # The existing systemd starter is held, never executed by this controller. + starter = Path(STARTER) + raw, metadata = pin.read_file(starter, 65536, 0o755) + require(sha(raw) == STARTER_SHA, 'exact_reviewed_public_starter_script') + files[str(starter)] = dict(sha256=STARTER_SHA, metadata=metadata) + directories = include_directories(pin) + fields = ('FragmentPath', 'DropInPaths', 'EnvironmentFiles', 'User', 'Group', 'Restart', 'KillMode') + raw = operator.run(['/usr/bin/systemctl', 'show', '--all', '--property=' + ','.join(fields), + '--', 'chrony.service'], limit=16384) + unit = {} + for line in raw.decode('ascii').splitlines(): + key, separator, value = line.partition('=') + require(separator and key in fields and key not in unit, 'unique_complete_loaded_unit_property') + unit[key] = value + require(set(unit) == set(fields) and unit['FragmentPath'] == '/usr/lib/systemd/system/chrony.service' + and unit['DropInPaths'] == '' and unit['EnvironmentFiles'] == '/etc/default/chrony (ignore_errors=yes)' + and unit['User'] == '_chrony' and unit['Group'] == '' and unit['Restart'] == 'no' + and unit['KillMode'] == 'control-group', 'exact_loaded_chrony_unit_properties_no_dropins') + commands = typed_commands(pin, operator) + return dict(files=files, include_directories=directories, unit=unit, commands=commands, + existing_makestep=dict(threshold_seconds=1, updates=3), configuration_changed=False) + + +def namespace(pin, daemon_pid): + result = {} + for path, expected in ((MAIN, MAIN_SHA), (LOCAL, LOCAL_SHA)): + raw, metadata = pin.read_file(path, 65536, 0o644) + require(sha(raw) == expected, 'reviewed_apparmor_source_unchanged') + result[str(path)] = dict(sha256=expected, metadata=metadata) + require(bounded_kernel(POLICY / 'name', 256).strip() == b'/usr/sbin/chronyd' + and bounded_kernel(POLICY / 'mode', 256).strip() == b'enforce' + and sha(bounded_kernel(POLICY / 'raw_data')) == POLICY_SHA + and bounded_kernel(Path('/proc') / str(daemon_pid) / 'attr/apparmor/current', 4096).strip() + == b'/usr/sbin/chronyd (enforce)', 'actual_same_enforcing_loaded_policy') + result['loaded_policy_sha256'] = POLICY_SHA + for name in ('/run/rmm-time-source', '/run/rmm-time-source/clients'): + fd = pin.directory(Path(name)) + try: + metadata = pin.stable_directory(os.fstat(fd)) + access = acl(fd, 'system.posix_acl_access') + default = acl(fd, 'system.posix_acl_default') + expected = struct.pack(' 0, 'readiness_read_command_budget_exhausted') + return original_run(args, timeout=min(timeout, remaining), limit=limit) + + operator.run = bounded_read + attempts = 0 + try: + for index in range(1, 26): + if time.monotonic() >= deadline: + break + # Guard failures are never swallowed as transient synchronization. + guard() + if time.monotonic() >= deadline: + break + observed_tracking = tracking(operator, allow_unready=True) + observed_kernel = kernel_query(allow_unready=True) + guard() + elapsed = time.monotonic() - started + ready = observed_tracking['ready'] and observed_kernel['ready'] and elapsed <= READINESS_SECONDS + save('readiness-' + str(index).zfill(2) + '.json', dict(binding, attempt=index, + elapsed_seconds=elapsed, deadline_seconds=READINESS_SECONDS, ready=ready, + tracking=observed_tracking, kernel=observed_kernel, no_restart=True, + no_pin_write=True, native_source_quality_qualified=False)) + attempts = index + if ready: + save('readiness.json', dict(binding, attempts=attempts, elapsed_seconds=elapsed, + deadline_seconds=READINESS_SECONDS, ready=True, tracking=observed_tracking, + kernel=observed_kernel, native_source_quality_qualified=False)) + return observed_tracking, observed_kernel + if time.monotonic() >= deadline: + break + time.sleep(max(0, min(1, deadline - time.monotonic()))) + save('readiness.json', dict(binding, attempts=attempts, deadline_seconds=READINESS_SECONDS, + ready=False, budget_exhausted=True, no_restart_retry=True, no_pin_write=True, + native_source_quality_qualified=False)) + raise GuardDenied('bounded_readonly_reacquisition_not_ready_original_read_only') + finally: + operator.run = original_run + + +def source_unchanged(pin, original): + original.operator_guard() + for phase, held in original.records.items(): + require(pin.read_file(original.case / phase / 'result.json') == held, 'historical_source_phase_unchanged') + for path, held in original.source_records.items(): + require(pin.read_file(path, 2 * 1024 * 1024) == held, 'historical_source_provenance_unchanged') + require(original.operator.verify_workspace(original.case)['manifest_sha256'] == original.manifest_sha, + 'original_workspace_unchanged') + for path, recorded, metadata in original.artifacts.values(): + raw, current = pin.read_file(path, 32 * 1024 * 1024, 0o500) + require(current == metadata and sha(raw) == recorded['sha256'], 'original_artifact_unchanged') + + +def generation(before, after): + for key in ('builder', 'runtime', 'boot_id', 'chrony_image_metadata'): + require(before[key] == after[key], 'same_boot_application_builder_daemon_image') + old, new = before['chrony_binding'], after['chrony_binding'] + require(old['fixed_images'] == new['fixed_images'], 'same_actual_fixed_daemon_and_wrapper_images') + changed_unit = ('MainPID', 'InvocationID') + require({k: v for k, v in old['unit'].items() if k not in changed_unit} + == {k: v for k, v in new['unit'].items() if k not in changed_unit} + and old['unit']['InvocationID'] != new['unit']['InvocationID'], 'one_new_same_configuration_service_invocation') + require(old['socket_kernel_inode'] != new['socket_kernel_inode'], 'new_actual_command_socket') + require(len(new['processes']) == len(old['processes']) == 3 + and min(p['birth_ticks'] for p in new['processes']) > max(p['birth_ticks'] for p in old['processes']), + 'three_new_actual_process_births') + for key in ('schema_version', 'daemon_uid', 'daemon_gid', 'daemon_image_sha256'): + require(before['chrony_observation'][key] == after['chrony_observation'][key], 'same_pinned_daemon_role_and_image') + require(after['chrony_observation']['daemon_birth_ticks'] != before['chrony_observation']['daemon_birth_ticks'], + 'new_actual_daemon_generation') + + +def host_read(pin): + records = {} + for name in RECORDS: + try: + raw, metadata = pin.read_file(BASE / name, 8 * 1024 * 1024 if name == 'restart.log' else 65536) + records[name] = dict(sha256=sha(raw), metadata=metadata, + record=pin.parsed(raw) if name.endswith('.json') else None) + except FileNotFoundError: + records[name] = None + print(pin.encoded(dict(profile=PROFILE, case=CASE, read_only=True, records=records, + public_pin_metadata=pin.targets_metadata(), no_restart=True, no_source_query=True)).decode(), end='') + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('command', choices=('host-preflight', 'host-restart', 'host-read')) + args = parser.parse_args() + require(sys.flags.isolated == 1 and os.geteuid() == 0 and os.uname().machine == 'aarch64', + 'isolated_root_server_arm64_only') + os.umask(0o077) + pin, pin_guard = load_pin_controller() + if args.command == 'host-read': + host_read(pin) + return + operator, operator_guard = pin.load_operator() + original = pin.Original(ORIGINAL, operator, operator_guard) + own_path = Path(__file__) + own = pin.read_file(own_path, 128 * 1024) + require(own_path.name == 'chrony_generation_bootstrap.py' and own_path.parent.name == sha(own[0]), + 'fixed_protected_content_addressed_controller') + held_pin = pin.read_file(PUBLIC_PIN, 8192) + require(len(held_pin[0]) == 194 and sha(held_pin[0]) == OLD_PIN_SHA + and pin.parsed(held_pin[0]) == original.fresh(), 'exact_old_public_pin_and_generation') + old_peer = pin.read_file(ORIGINAL / 'probe-peer-acceptance-v1/result.json', 65536) + require(sha(old_peer[0]) == OLD_PEER_RESULT_SHA and pin.parsed(old_peer[0])['exit_code'] == 1 + and pin.parsed(old_peer[0])['source_quality_qualified'] is False, 'retained_failed_peer_origin') + old_pids = [os.pidfd_open(value['pid']) for value in original.expected['chrony_binding']['processes']] + phase_fd = etc_fd = -1 + try: + before = operator.preflight() + require(pin.observation_key(before) == original.expected, 'fresh_original_before_restart') + config = configuration(pin, operator) + peer = namespace(pin, before['chrony_observation']['daemon_pid']) + absent = no_broker(operator) + quality = tracking(operator) + kernel = kernel_query() + binding = dict(profile=PROFILE, case=CASE, original_case=ORIGINAL.name, + controller_sha256=sha(own[0]), + pin_controller_sha256=PIN_CONTROLLER_SHA, operator_sha256=pin.OPERATOR_SHA, + old_public_pin_sha256=OLD_PIN_SHA, failed_peer_result_sha256=OLD_PEER_RESULT_SHA, + config_receipt_sha256=CONFIG_RECEIPT_SHA, source_tar_sha256=original.source_sha, + manifest_sha256=original.manifest_sha, loaded_policy_sha256=POLICY_SHA, + include_receipt_sha256=INCLUDE_RECEIPT_SHA, dbus_abi_receipt_sha256=DBUS_RECEIPT_SHA, + starter_sha256=STARTER_SHA) + if args.command == 'host-preflight': + print(pin.encoded(dict(binding, read_only=True, proposed_restart_once=True, + existing_makestep_can_step_on_start=True, before=before, configuration=config, + namespace=peer, broker_absent=absent, tracking=quality, kernel=kernel, + user_approval_required=True)).decode(), end='') + return + parent = pin.directory(BASE.parent) + try: + pin.absence(parent, CASE) + original.fresh() + os.mkdir(CASE, 0o700, dir_fd=parent) + os.fsync(parent) + finally: + os.close(parent) + phase_fd = pin.directory(BASE) + save = lambda name, value: create_record(phase_fd, name, pin.encoded(value)) + save('intent.json', dict(binding, restart_once=True, old_pin_cas_only=True, + existing_makestep_can_step_on_start=True, no_automatic_retry=True)) + save('before.json', dict(binding, actual=before, configuration=config, namespace=peer, + broker_absent=absent, tracking=quality, kernel=kernel, public_pin_metadata=held_pin[1])) + pin.exclusive(phase_fd, 'old-public-pin.bin', held_pin[0]) + def stable_common(): + pin_guard() + require(pin.read_file(own_path, 128 * 1024) == own, 'generation_controller_unchanged') + source_unchanged(pin, original) + require(configuration(pin, operator) == config and no_broker(operator) == absent, + 'same_configuration_no_broker_or_keys') + require(pin.read_file(ORIGINAL / 'probe-peer-acceptance-v1/result.json', 65536) == old_peer, + 'failed_peer_origin_unchanged') + stable_common() + original.fresh() + etc_fd = pin.directory(PUBLIC_PIN.parent) + fcntl.flock(etc_fd, fcntl.LOCK_EX | fcntl.LOCK_NB) + require(pin.read_file(PUBLIC_PIN, 8192) == held_pin, 'original_pin_cas_precondition') + require(namespace(pin, before['chrony_observation']['daemon_pid']) == peer, + 'original_actual_loaded_policy_namespace_before_restart') + save('restart-intent.json', dict(binding, argv=['/usr/bin/systemctl', 'restart', '--', 'chrony.service'])) + code = operator.long_command(['/usr/bin/systemctl', 'restart', '--', 'chrony.service'], BASE / 'restart.log', 15) + save('restart-exit.json', dict(binding, exit_code=code)) + require(code == 0, 'restart_completed_once_otherwise_original_read_only') + after = operator.preflight() + generation(before, after) + save('after-restart.json', dict(binding, actual=after, native_source_quality_qualified=False)) + for fd in old_pids: + poll = select.poll() + poll.register(fd, select.POLLIN) + require(bool(poll.poll(0)), 'all_held_original_chrony_processes_exited') + stable_common() + require(namespace(pin, after['chrony_observation']['daemon_pid']) == peer, + 'same_loaded_enforcing_policy_and_peer_namespace') + def same_new_generation(): + stable_common() + require(pin.observation_key(operator.preflight()) == pin.observation_key(after) + and namespace(pin, after['chrony_observation']['daemon_pid']) == peer + and pin.read_file(PUBLIC_PIN, 8192) == held_pin, + 'same_new_generation_boot_configuration_namespace_old_pin_during_readiness') + after_tracking, after_kernel = await_readiness(operator, same_new_generation, save, binding) + new_raw = pin.encoded(after['chrony_observation']) + require(set(after['chrony_observation']) == pin.PIN_KEYS and len(new_raw) <= 256, + 'bounded_actual_six_field_new_public_pin') + pin.absence(etc_fd, TEMP_PIN) + require(pin.read_file(PUBLIC_PIN, 8192) == held_pin, 'old_public_pin_exact_cas_before_temp') + save('cas-intent.json', dict(binding, new_public_pin_sha256=sha(new_raw), + new_public_pin_bytes=len(new_raw), actual_new_observation=after['chrony_observation'])) + pin.exclusive(etc_fd, TEMP_PIN, new_raw) + temp = pin.read_file(PUBLIC_PIN.parent / TEMP_PIN, 256) + stable_common() + require(pin.observation_key(operator.preflight()) == pin.observation_key(after) + and pin.read_file(PUBLIC_PIN, 8192) == held_pin + and temp == pin.read_file(PUBLIC_PIN.parent / TEMP_PIN, 256), 'held_new_generation_and_atomic_pin_cas') + os.replace(TEMP_PIN, PUBLIC_PIN.name, src_dir_fd=etc_fd, dst_dir_fd=etc_fd) + os.fsync(etc_fd) + actual_pin = pin.read_file(PUBLIC_PIN, 256) + require(actual_pin[0] == new_raw + and {k: v for k, v in actual_pin[1].items() if k != 'ctime_ns'} + == {k: v for k, v in temp[1].items() if k != 'ctime_ns'} + and actual_pin[1]['ctime_ns'] >= temp[1]['ctime_ns'], + 'same_fresh_root_public_pin_after_atomic_replace') + pin.exclusive(phase_fd, 'new-public-pin.bin', new_raw) + stable_common() + require(pin.observation_key(operator.preflight()) == pin.observation_key(after) + and namespace(pin, after['chrony_observation']['daemon_pid']) == peer, + 'final_actual_generation_runtime_and_policy_stable') + save('after.json', dict(binding, actual=after, tracking=after_tracking, kernel=after_kernel, + public_pin_sha256=sha(new_raw), public_pin_metadata=actual_pin[1], configuration=config, namespace=peer)) + save('result.json', dict(binding, new_public_pin_sha256=sha(new_raw), new_public_pin_metadata=actual_pin[1], + new_chrony_observation=after['chrony_observation'], restart_exit_code=0, + runtime_boot_configuration_images_preserved=True, new_generation_pinned=True, + source_quality_qualified=False, native_source_sampled=False, signer_created=False, + signed_attestation=False, broker_started=False, no_rmm_jobs=True)) + print(pin.encoded(dict(binding, completed=True, source_quality_qualified=False)).decode(), end='') + except Exception as error: + if phase_fd >= 0: + create_record(phase_fd, 'failure.json', pin.encoded(dict(profile=PROFILE, case=CASE, + failed=True, fixed_tag=failure_tag(error), state_unknown=True, + read_original_case_only=True, no_automatic_rollback=True))) + raise + finally: + for fd in old_pids + [phase_fd, etc_fd]: + if fd >= 0: + os.close(fd) + + +if __name__ == '__main__': + try: + main() + except Exception as error: + print(json.dumps(dict(profile=PROFILE, case=CASE, failed=True, + fixed_tag=failure_tag(error), read_original_case_only=True))) + raise SystemExit(1) diff --git a/docs/handover.md b/docs/handover.md index 61ee435..628441b 100644 --- a/docs/handover.md +++ b/docs/handover.md @@ -1,5 +1,11 @@ # Übergabe — Linux-MVP abgeschlossen, Windows wird fortgesetzt +**Chrony-Generationsplan konkret und lesend geprüft:** d5d56b38, tatsächlicher +Preflightb7c05714 bestanden (Normal/Stratum3,0.123ms Offset); ursprüngliche +Runtime/Config/Pin erhalten. [Plan und Belege](server-time-source-chrony-generation-bootstrap.md). +Einmaliger Zeitdienstrestart samt öffentlichem Pin-CAS weiterhin NICHT +ausgeführt; ausdrückliche Userfreigabe wegen möglichem normalen Start-Sync nötig. + **Passiver Windows-Upgradecontroller nativ quellengeprüft:** korrigierter 77fb-Generator, AST/C#compile-only und14reineAktionsfixtures auf Windows bestanden; geschlossene Wirkungssperre, RMM-/Serverzeugen erhalten. diff --git a/docs/server-time-source-chrony-generation-bootstrap.md b/docs/server-time-source-chrony-generation-bootstrap.md new file mode 100644 index 0000000..0bf385d --- /dev/null +++ b/docs/server-time-source-chrony-generation-bootstrap.md @@ -0,0 +1,129 @@ +# Proposed one-time Chrony generation change + +Status: source-only preparation, not approved or executed. A separate explicit +user approval is required before the target restart. This is server bootstrap, +not an RMM job approval. No existing failed source acceptance becomes a PASS. + +The named-client source remains the intended transport. The rejected abstract +candidate is retained only in its private freeze: Chrony 4.8/4.9 reconstructs +reply paths with strlen and loses an abstract sender's random name. The loaded +AppArmor policy is already byte-bound to the newly compiled policy; the apparent +file-query denial was libapparmor's last-byte truncation and disappears with the +corrected query length. Upstream Linux 7.0's datagram peer check instead uses the +command socket's stored label directly, with no newest-generation resolution. +A new daemon/socket generation is the proposed remedy for that remaining +source-supported stale-label cause. No additional capability or AppArmor rule +change is proposed. + +The finite operation is: + +1. Read and bind the original 5b source/build/public-pin records, actual complete + daemon PID/birth/image/cgroup/socket holder, boot, builder, application runtime, + AppArmor main/local bytes and currently enforcing policy. Hold all three old + Chrony pidfds. Require no broker unit/binary, time signer seed or public time + key, and retain those absence conditions throughout. +2. Bind the exact loaded service definition and every actually included Chrony + configuration file. Read only bounded public configuration projections and + hashes, never private key contents. Require a normal leap state and small + measured tracking offset before the restart. Existing makestep, + initstepslew, leap/clock-control and command-socket options must be reviewed + explicitly; this operation changes none of them. A pre-restart small offset + alone does not prove a restart cannot trigger an existing step policy. +3. Create a new private generation case and intent before effects. Save the exact + old root:root 0600 single-link public pin bytes and metadata and fsync the + backup. Save a separate restart intent and invoke only + `/usr/bin/systemctl restart -- chrony.service` once, with a bounded transport + and owned-process watchdog. Do not retry after an error or lost reply. +4. Read the new actual complete daemon/socket binding. All old processes must be + dead; the new invocation, births and command-socket kernel inode must differ. + Daemon/wrapper executable bytes, UID/GID, unit/configuration bytes, boot, + builder and application runtime must remain equal. Require the original + AppArmor rules and enforce mode on the new daemon. Run only bounded tracking + and modes=0 kernel queries for at most a 25-second reacquisition budget. Each + round rechecks the same new PID/birth/socket, boot, configuration, namespace + and unchanged old pin before and after reading. Fixed create-only + `readiness-01.json` through `readiness-25.json` retain negative observations; + only actual normal tracking at an absolute offset of at most 5 ms and the + original kernel bounds permit the pin CAS. Command timeouts use the remaining + budget. These observations never restart/resync Chrony or qualify a native + source sample. Deadline or transport/guard failure leaves the old pin and + requires original readback, with no repeat of effects. +5. Derive the new six-field public pin solely from that actual binding. Before + changing the pin, recheck all guards and compare both original pin bytes and + full metadata. Write a fixed own create-only temporary root:root 0600 + single-link file, fsync it, then atomically replace the pin and fsync the held + protected directory. Save CAS intent before replace and read back the exact + new bytes/metadata. Old pin bytes remain in the new case. The old pin is + exactly 194 bytes, as verified by Root read receipt + `d1bf11677e5d85c411e25d4c37f9dd9f910177a111f19fb1329e5b28151a518e`; + the new canonical length can differ with PID/birth digit + counts and must be bounded rather than padded. +6. Preserve before/after evidence and a result explicitly stating no native + quality sample, signer, signature, broker or RMM job. Subsequent qualification + must use a new case and the new actual generation. Original 5b GROUP/DAC/peer + failures and their old pin remain unchanged historical records. + +`host-read` must only read the new original case and bounded target metadata. It +must not repeat restart, pin CAS, tracking command, native probe or configuration +write. A failure after restart can leave a running new Chrony generation and the +old pin; this is a closed/unknown state, not authority to restore the old pin, +restart again, adopt a new case or bypass a quality gate. There is no automatic +rollback, OS update, reboot, resync, makestep command, service enablement, broker +installation or key generation. + +The source binds Root's actual configuration/service proof +`7d5c7566a054ce353733155fbc2b98ef2a4d3f6d758bb85bd0e3ffd31bdeb22e`: +five exact public file hashes, the three closed include directories, loaded +service properties and a held protected starter script. Existing `makestep 1 3` +can step the clock during normal startup synchronization. It remains unchanged +and is explicitly part of the operation requiring user approval. There is no +approved or executed target restart from this source preparation alone. + +Root's additional read-only include proof +`ee557a17e7188dcf2211cde5df575ad3c101a6412f564eb53dc385a77262c22d` +fixes the actual closed sets: `conf.d` contains exactly `README` and +`ubuntu-nts.conf`; `sources.d` contains exactly `README` and +`ubuntu-ntp-pools.sources`. Each README is an ignored package document checked +only for protected regular-file metadata. The five configuration hashes remain +mandatory. `/run/chrony-dhcp` is absent. A held protected `/run` parent and +nofollow leaf lookup prove its absence before/after and during readiness; this +operation creates or adopts no DHCP directory. Any extra entry, symlink README +or appearing DHCP object denies the operation. + +Loaded command lists are read through five fixed native D-Bus properties, +using the ABI proven in Root receipt +`6ca943b071bb85c8c3f84ace00135e97acea48c6b0e0fcce3550b253aa67b092`. +All four `ExecStartPre`, `ExecStartPost`, `ExecStop` and `ExecStopPost` properties +must be typed `a(sasbttttuii)` with an actually empty array. The operation never +infers an empty list from omitted `systemctl show` output. `ExecStartEx` must +contain exactly the fixed starter path, `-n`, literal `$DAEMON_OPTS` and the +`no-setuid` flag corresponding to the existing unit's `!` prefix. Its typed +runtime timestamp/PID/status fields are validated and excluded from static +configuration equality; the actual process generation has its independent full +binding. The starter's SHA256 is fixed to +`48ae26b9a01b359ac6a743c074265e4b19a3ed99bbc4c46953850c75edde8e1c`. +The controller does not execute the starter or source `/etc/default/chrony`. +Only the unchanged systemd service definition executes that existing wrapper. + +Own guard failures may expose a bounded fixed tag matching `[a-z0-9_]+`. +Unexpected exceptions expose only `unexpected_generation_exception`, without +free exception text, paths or configuration contents. + +## Tatsächlich lesender finaler Preflight bestanden + +Am2026-11-15 lief ausschließlich `host-preflight` des unabhängig geprüften +Controllersd5d56b38 auf dem permanenten Server erfolgreich. Rootcallb7c05714, +Receipt `f89876d7f61b8c195ed65c8b935f88dac9eb0a4b6fd4d742f1c65b4c6f723a74`. +Aktuelle ursprüngliche Generation, Konfiguration, typisierte Unitkommandos, +Namespace, Altpin194Bytes/203f und Brokerabwesenheit sind geprüft. Tracking +meldet Stratum3/LeapNormal und0.122816ms absoluten Offset; modes0-Kernelquery +meldet state0/status0/maxerror13.957ms. Das ist kein gemeinsamer +NativeTimeSource-Qualitätsnachweis und keine Freigabe des Restarts. + +Frühere ausschließlich lesende Preflights verweigerten an zu enger +Include-Verzeichnisannahme bzw. ausgelassenen leeren systemctl-Kommandolisten. +Die tatsächlichen README-/DHCP-Abwesenheits- und D-Bus-Belege führten zu den +engen oben dokumentierten Quellenkorrekturen; kein früherer Misserfolg wird +umgeschrieben. Keine Restartphase angelegt, kein Service gestoppt oder +Publicpin ersetzt. `host-restart` wartet weiterhin auf ausdrückliche +Userfreigabe des konkreten Plans samt möglichem normalen Start-Sync-Effekt.