#!/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)