Prepare reviewed Chrony generation change with passing read-only server preflight
Rust development slice / linux (push) Failing after 6s
Rust development slice / linux (push) Failing after 6s
This commit is contained in:
@@ -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)
|
||||
@@ -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.
|
||||
Reference in New Issue
Block a user