Prepare reviewed Chrony generation change with passing read-only server preflight
Rust development slice / linux (push) Failing after 6s

This commit is contained in:
2026-11-15 11:42:32 +01:00
parent f6a7fd057a
commit be57d98955
3 changed files with 719 additions and 0 deletions
@@ -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('<I', 2) + b''.join(struct.pack('<HHI', *entry) for entry in
((1, 7, 0xffffffff), (4, 1, 0xffffffff), (8, 1, 989), (16, 1, 0xffffffff), (32, 0, 0xffffffff)))
require(metadata['uid'] == 0 and stat.S_IMODE(metadata['mode']) == 0o710
and metadata['gid'] == (989 if name.endswith('clients') else 10001)
and default is None and access == (None if name.endswith('clients') else expected),
'exact_reviewed_peer_namespace_modes_and_acls')
result[name] = dict(metadata=metadata, access_acl=access.hex() if access is not None else None)
if name.endswith('clients'):
require(not os.listdir(fd), 'no_unknown_client_socket_leftovers')
finally:
os.close(fd)
return result
def no_broker(operator):
for path in ABSENT:
try:
path.lstat()
except FileNotFoundError:
continue
raise GuardDenied('no_broker_or_time_key_may_exist')
raw = operator.run(['/usr/bin/systemctl', 'show', '--all', '--property=LoadState,ActiveState,MainPID',
'--', 'rmm-time-broker.service'], limit=4096)
state = dict(line.split('=', 1) for line in raw.decode('ascii').splitlines())
require(state == {'LoadState': 'not-found', 'ActiveState': 'inactive', 'MainPID': '0'},
'no_loaded_or_active_time_broker')
return state
def tracking(operator, allow_unready=False):
raw = operator.run(['/usr/bin/chronyc', '-n', 'tracking'], timeout=3, limit=8192)
values = {}
for line in raw.decode('ascii').splitlines():
key, separator, value = line.partition(':')
require(separator and key.strip() not in values, 'unique_tracking_field')
values[key.strip()] = value.strip()
leap = values.get('Leap status')
require(leap in ('Normal', 'Insert second', 'Delete second', 'Not synchronised')
and re.fullmatch(r'[0-9]|1[0-6]', values.get('Stratum', '')), 'bounded_tracking_leap_and_stratum')
match = re.fullmatch(r'([0-9]+\.[0-9]+) seconds (?:slow|fast) of NTP time', values.get('System time', ''))
require(match and math.isfinite(float(match[1])), 'finite_tracking_system_offset')
offset = float(match[1])
ready = leap == 'Normal' and 1 <= int(values['Stratum']) <= 15 and offset <= 0.005
require(allow_unready or ready, 'tracking_normal_synchronized_offset_at_most_5ms')
return dict(output_sha256=sha(raw), leap=leap, stratum=int(values['Stratum']), ready=ready,
absolute_system_offset_seconds=offset, existing_makestep_preserved=True,
source_quality_qualified=False)
class Timex(ctypes.Structure):
# Linux asm-generic timex ABI for the fixed 64-bit aarch64/glibc host.
_fields_ = [('modes', ctypes.c_uint), ('offset', ctypes.c_long), ('freq', ctypes.c_long),
('maxerror', ctypes.c_long), ('esterror', ctypes.c_long), ('status', ctypes.c_int),
('constant', ctypes.c_long), ('precision', ctypes.c_long), ('tolerance', ctypes.c_long),
('time_sec', ctypes.c_long), ('time_usec', ctypes.c_long), ('tick', ctypes.c_long),
('ppsfreq', ctypes.c_long), ('jitter', ctypes.c_long), ('shift', ctypes.c_int),
('stabil', ctypes.c_long), ('jitcnt', ctypes.c_long), ('calcnt', ctypes.c_long),
('errcnt', ctypes.c_long), ('stbcnt', ctypes.c_long), ('tai', ctypes.c_int),
('reserved', ctypes.c_int * 11)]
def kernel_query(allow_unready=False):
require(ctypes.sizeof(ctypes.c_long) == 8 and ctypes.sizeof(Timex) == 208
and Timex.status.offset == 40 and Timex.maxerror.offset == 24, 'fixed_readonly_kernel_query_abi')
libc = ctypes.CDLL('libc.so.6', use_errno=True)
libc.adjtimex.argtypes = [ctypes.POINTER(Timex)]
libc.adjtimex.restype = ctypes.c_int
value = Timex() # All zeros, especially modes=0: query only.
require(value.modes == 0, 'kernel_query_never_sets_modes')
state = libc.adjtimex(ctypes.byref(value))
require(state in range(6) and 0 <= value.status < 2 ** 31 and 0 <= value.maxerror < 2 ** 63,
'bounded_native_kernel_query_values')
ready = state in range(5) and value.status & (0x40 | 0x1000) == 0 and value.maxerror <= 500000
require(allow_unready or ready, 'native_kernel_readiness_bounds')
return dict(state=state, status=value.status, maxerror_ns=value.maxerror * 1000,
modes=0, ready=ready, source_quality_qualified=False)
def await_readiness(operator, guard, save, binding):
started = time.monotonic()
deadline = started + READINESS_SECONDS
original_run = operator.run
def bounded_read(args, timeout=15, limit=1024 * 1024):
remaining = deadline - time.monotonic()
require(remaining > 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)
+6
View File
@@ -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.
@@ -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.