Qualify protected Chrony socket permissions on cloud Linux
Rust development slice / linux (push) Failing after 6s

This commit is contained in:
2026-11-15 01:57:21 +01:00
parent c68bc0153e
commit 2c0f07046e
6 changed files with 404 additions and 10 deletions
+31 -5
View File
@@ -675,6 +675,17 @@ impl Drop for Client {
}
}
// Linux pathname DGRAM send requires socket write permission; read/execute
// bits grant no sending authority. Directory ancestry is separately held and
// verified. Neither group nor other may write this daemon-owned socket.
fn protected_server_socket(socket: Identity, uid: u32, gid: u32) -> bool {
socket.mode & libc::S_IFMT == libc::S_IFSOCK
&& socket.links == 1
&& socket.uid == uid
&& socket.gid == gid
&& socket.mode & 0o022 == 0
}
/// Root-only source broker primitive. No daemon discovery, adoption, commands,
/// configurable endpoint, retry, IP transport or time-setting entrypoint.
pub struct NativeTimeSource {
@@ -698,11 +709,11 @@ impl NativeTimeSource {
)?;
let server_identity = socket_identity(server_dir.as_raw_fd(), "chronyd.sock")?;
ensure!(
server_identity.mode & libc::S_IFMT == libc::S_IFSOCK
&& server_identity.links == 1
&& server_identity.uid == daemon.pin.daemon_uid
&& server_identity.gid == daemon.pin.daemon_gid
&& server_identity.mode & 0o007 == 0,
protected_server_socket(
server_identity,
daemon.pin.daemon_uid,
daemon.pin.daemon_gid,
),
"TIME_CHRONY_SOCKET_PROTECTION"
);
Ok(Self {
@@ -854,6 +865,21 @@ mod tests {
.unwrap();
let old = UnixDatagram::bind(path.join("own.sock")).unwrap();
let expected = socket_identity(dir.as_raw_fd(), "own.sock").unwrap();
let server = Identity {
mode: libc::S_IFSOCK | 0o755,
..expected
};
assert!(protected_server_socket(server, server.uid, server.gid));
for mode in [0o775, 0o757] {
assert!(!protected_server_socket(
Identity {
mode: libc::S_IFSOCK | mode,
..server
},
server.uid,
server.gid,
));
}
std::fs::rename(path.join("own.sock"), path.join("held.sock")).unwrap();
let new = UnixDatagram::bind(path.join("own.sock")).unwrap();
assert!(unlink_owned(dir.as_raw_fd(), "own.sock", expected).is_err());
+1 -1
View File
@@ -480,7 +480,7 @@ def chrony_observation():
directory = os.open('/run/chrony', os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW)
dir_identity = fd_metadata(directory)
require(stat.S_ISDIR(dir_identity['mode']) and dir_identity['uid'] == 989 and
dir_identity['gid'] == 989 and stat.S_IMODE(dir_identity['mode']) == 0o755,
dir_identity['gid'] == 989 and stat.S_IMODE(dir_identity['mode']) == 0o700,
'actual fixed protected Chrony socket directory')
pidfile = os.open('chronyd.pid', os.O_RDONLY | os.O_NOFOLLOW, dir_fd=directory)
pid_identity = fd_metadata(pidfile)
@@ -0,0 +1,309 @@
#!/usr/bin/env python3
"""Frozen four Linux source units only; no actual Chrony or kernel query; no updater service or Apply.
Prepare copies the independently reviewed snapshot locally. Execute is one
root-only Cloud-VM fixture run. After any lost reply read the original case;
never execute it again or substitute another binary/source generation.
"""
import argparse
import base64
import hashlib
import inspect
import json
import os
from pathlib import Path
import stat
import uuid
import windows_msi_runtime_acceptance as support
ROOT = Path(__file__).resolve().parents[1]
ACCESS_ROOT = ROOT.parent / 'rust-discovery'
QUALIFICATION = ROOT / 'devstate/time-source-qualification/7a8cb5be-41b3-400a-bd9b-b4b6f505a6e9'
STATE = ROOT / 'devstate/time-source-socket-native-linux'
PROFILE = 'rmm.time-source.four-socket-permission-units.v1'
RECEIPT_SHA = '74759e286ba7c9762fe4c455da952a0e62de48f55ea643e0a8f435d2128497a5'
INPUTS_SHA = 'c0067889fa6e79e5b1dc2ad46685613fd0b379b30a4541670f635140405718d9'
BINARY_SHA = '9bd41ff166aeaae45fdf3dda2d72b04fc30e5ef87a181fe733c47e511a836d59'
BINARY_BYTES = 1169800
TESTS = sorted(['native::tests::clock_brackets_reject_suspend_step_backwards_and_total_timeout', 'native::tests::socket_cleanup_preserves_replaced_name_and_removes_only_exact_own_inode', 'tracking::tests::exact_packet_sequence_and_network_source', 'tracking::tests::signed_float_ceil_and_overflow_are_conservative'])
AGENT_SHA = '0a7ad6eefaefda79ee80b6a41b2df904e9e7f50ae6ebeed01b98c25b6ce5c06f'
HELPER_SHA = '79442727c3ba31cda02a8bc0e67481f14db9f39fc07520a880a90b64f10f1eaf'
def sha(raw):
return hashlib.sha256(raw).hexdigest()
def save_local(path, value):
support.save(path, value)
fd = os.open(path.parent, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW)
try:
os.fsync(fd)
finally:
os.close(fd)
def copy_exact(source, destination, digest, size):
metadata = source.lstat()
support.require(stat.S_ISREG(metadata.st_mode) and metadata.st_nlink == 1
and metadata.st_uid in (0, os.getuid()) and not metadata.st_mode & 0o002
and metadata.st_size == size and size <= 2 * 1024 * 1024, 'bounded regular frozen input')
raw = source.read_bytes()
support.require(sha(raw) == digest, 'frozen snapshot input hash')
destination.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
support.private(destination.parent, True)
fd = os.open(destination, os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW | os.O_WRONLY, 0o600)
with os.fdopen(fd, 'wb') as stream:
stream.write(raw); stream.flush(); os.fsync(stream.fileno())
fd = os.open(destination.parent, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW)
try:
os.fsync(fd)
finally:
os.close(fd)
def verify_case(folder):
value = support.load(folder / 'manifest.json')
support.require(value['profile'] == PROFILE and value['tests'] == TESTS
and value['runner_sha256'] == sha(Path(__file__).read_bytes())
and value['receipt_sha256'] == RECEIPT_SHA and value['binary_sha256'] == BINARY_SHA
and value['binary_bytes'] == BINARY_BYTES, 'same original reviewed manifest')
support.require(sha((folder / 'receipt.json').read_bytes()) == RECEIPT_SHA
and sha((folder / 'inputs.json').read_bytes()) == INPUTS_SHA, 'original qualification provenance')
source = support.load(folder / 'inputs.json')
support.require(len(source) == 7 and source == value['source_files'], 'exact frozen seven provider inputs')
for item in source:
path = Path(item['path'])
support.require(not path.is_absolute() and '..' not in path.parts, 'fixed snapshot relative path')
file = folder / 'source' / path
support.private(file)
support.require(file.stat().st_size == item['bytes'] and sha(file.read_bytes()) == item['sha256'], 'retained source freeze')
binary = folder / 'time-contract-tests'; support.private(binary)
support.require(binary.stat().st_size == BINARY_BYTES and sha(binary.read_bytes()) == BINARY_SHA, 'original qualified test bytes')
for path, digest in value['transport_sources'].items():
support.require(sha((ROOT / path).read_bytes()) == digest, 'original strict transport source')
return value
def remote(p):
import base64
import hashlib
import json
import os
from pathlib import Path
import selectors
import signal
import stat
import subprocess
import time
import uuid
def require(ok, message):
if not ok:
raise RuntimeError(message)
def enc(value):
return json.dumps(value, sort_keys=True, separators=(',', ':')).encode()
def create(path, raw, mode=0o600):
fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, mode)
with os.fdopen(fd, 'wb') as stream:
stream.write(raw); stream.flush(); os.fsync(stream.fileno())
fd = os.open(path.parent, os.O_DIRECTORY | os.O_RDONLY | os.O_NOFOLLOW)
try:
os.fsync(fd)
finally:
os.close(fd)
def run(args, timeout=20):
# Keep the owned group leader unreaped until its entire group has been
# cleaned up. Its PID therefore cannot be recycled before killpg.
child = subprocess.Popen(args, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE,
stderr=subprocess.PIPE, start_new_session=True,
env={'PATH': '/usr/bin:/bin', 'LC_ALL': 'C', 'HOME': '/nonexistent'})
selector = selectors.DefaultSelector()
buffers = {'stdout': bytearray(), 'stderr': bytearray()}
deadline = time.monotonic() + timeout
try:
for stream, name in ((child.stdout, 'stdout'), (child.stderr, 'stderr')):
os.set_blocking(stream.fileno(), False); selector.register(stream, selectors.EVENT_READ, name)
while True:
require(time.monotonic() < deadline, 'owned native command timeout; read original case only')
for key, _ in selector.select(0.02):
raw = os.read(key.fileobj.fileno(), 4096)
if raw:
buffers[key.data].extend(raw)
require(len(buffers[key.data]) <= 65536, 'bounded native output')
else:
selector.unregister(key.fileobj)
ended = os.waitid(os.P_PID, child.pid, os.WEXITED | os.WNOHANG | os.WNOWAIT)
if ended is not None:
# Child remains a zombie until finally: no PID/group reuse.
os.killpg(child.pid, signal.SIGKILL)
for key in list(selector.get_map().values()):
while True:
try:
raw = os.read(key.fileobj.fileno(), 4096)
except BlockingIOError:
break
if not raw:
break
buffers[key.data].extend(raw)
require(len(buffers[key.data]) <= 65536, 'bounded native output')
code = ended.si_status if ended.si_code == os.CLD_EXITED else -ended.si_status
return code, bytes(buffers['stdout']), bytes(buffers['stderr'])
finally:
os.killpg(child.pid, signal.SIGKILL)
child.wait()
selector.close(); child.stdout.close(); child.stderr.close()
def metadata_identity(value):
return (value.st_dev, value.st_ino, value.st_uid, value.st_gid, value.st_mode,
value.st_nlink, value.st_size, value.st_mtime_ns, value.st_ctime_ns)
def hashed(path, maximum, process_image=False):
fd = os.open(path, os.O_RDONLY | os.O_CLOEXEC | (0 if process_image else os.O_NOFOLLOW))
with os.fdopen(fd, 'rb') as stream:
before = os.fstat(stream.fileno()); require(stat.S_ISREG(before.st_mode) and before.st_size <= maximum, 'bounded witness file')
digest = hashlib.sha256(); total = 0
while True:
raw = stream.read(32768)
if not raw:
break
total += len(raw); require(total <= maximum, 'bounded witness hash'); digest.update(raw)
after = os.fstat(stream.fileno())
require(metadata_identity(before) == metadata_identity(after) and total == before.st_size, 'stable witness hash')
return before, digest.hexdigest()
def witness():
out = {'boot_id': Path('/proc/sys/kernel/random/boot_id').read_text().strip(), 'services': {}, 'files': {}}
release = dict(line.split('=', 1) for line in Path('/etc/os-release').read_text().splitlines() if '=' in line)
require(release.get('ID', '').strip('"') == 'ubuntu' and release.get('VERSION_ID', '').strip('"') == '24.04', 'fixed native Ubuntu24.04')
out['os'] = {'id': 'ubuntu', 'version': '24.04', 'machine': os.uname().machine, 'kernel': os.uname().release}
for name, uid, binary in (
('rmm-agent-remote.service', 993, p['agent_sha256']),
('rmm-helper-cloud.service', 0, p['helper_sha256']),
('rmm-full-maintenance-helper.service', 0, p['helper_sha256'])):
code, stdout, _ = run(['/usr/bin/systemctl', 'show', name, '-p', 'ActiveState', '-p', 'MainPID', '-p', 'UnitFileState', '-p', 'InvocationID'])
require(code == 0, 'existing service read')
service = dict(line.split('=', 1) for line in stdout.decode().splitlines())
pid = int(service['MainPID']); require(service['ActiveState'] == 'active' and pid > 1, 'three existing services active')
proc = Path('/proc', str(pid)); birth = (proc / 'stat').read_text().rsplit(') ', 1)[1].split()[19]
ids = {line.split(':')[0]: line.split()[1:] for line in (proc / 'status').read_text().splitlines() if line.startswith(('Uid:', 'Gid:'))}
metadata, image = hashed(proc / 'exe', 256 * 1024 * 1024, process_image=True)
current = (proc / 'exe').stat()
require(ids['Uid'] == [str(uid)] * 4 and ids['Gid'] == ['984'] * 4 and image == binary
and (metadata.st_dev, metadata.st_ino) == (current.st_dev, current.st_ino)
and (proc / 'stat').read_text().rsplit(') ', 1)[1].split()[19] == birth, 'current generation/account/image')
out['services'][name] = dict(service, birth=birth, image=image, ids=ids)
code, stdout, _ = run(['/usr/bin/systemctl', 'show', 'rmm-apt-helper.service', '-p', 'ActiveState', '-p', 'UnitFileState'])
apt = dict(line.split('=', 1) for line in stdout.decode().splitlines())
require(code == 0 and apt == {'ActiveState': 'inactive', 'UnitFileState': 'disabled'}, 'APT remains closed')
out['apt'] = apt
for name in ('/etc/rmm-remote/helper-general.json', '/etc/rmm-remote/helper-full-maintenance.json',
'/etc/rmm-remote/full-maintenance-helper-proof.json', '/etc/systemd/system/rmm-full-maintenance-helper.service'):
path = Path(name); metadata = path.lstat()
require(not path.is_symlink() and stat.S_ISREG(metadata.st_mode) and metadata.st_uid == 0
and not metadata.st_mode & 0o022 and metadata.st_nlink == 1, 'protected known control')
current, digest = hashed(path, 65536)
require(metadata_identity(current) == metadata_identity(metadata), 'same known control file')
out['files'][name] = [metadata.st_dev, metadata.st_ino, metadata.st_uid, metadata.st_gid, metadata.st_mode,
metadata.st_size, metadata.st_mtime_ns, metadata.st_ctime_ns, digest]
for name in ('/var/lib/rmm-helper/consumption.sqlite', '/var/lib/rmm-helper/executor.lock',
'/var/lib/rmm-agent-remote/journal.sqlite', '/var/lib/rmm-agent-remote/consumption.sqlite'):
path = Path(name); metadata = path.lstat()
require(not path.is_symlink() and stat.S_ISREG(metadata.st_mode) and metadata.st_nlink == 1, 'existing state identity')
out['files'][name] = [metadata.st_dev, metadata.st_ino, metadata.st_uid, metadata.st_gid, metadata.st_mode]
return out
require(os.geteuid() == 0 and os.uname().machine == 'x86_64', 'fixed Cloud Linux root contract fixtures')
ident = str(uuid.UUID(p['id'])); require(ident == p['id'], 'canonical original case')
folder = Path('/var/tmp') / ('rmm-time-source-units-linux-' + ident)
if p['action'] == 'read':
metadata = folder.lstat()
require(stat.S_ISDIR(metadata.st_mode) and not folder.is_symlink() and metadata.st_uid == 0
and stat.S_IMODE(metadata.st_mode) == 0o700, 'own original case only')
result = folder / 'result.json'
return {'read_only': True, 'id': ident, 'entered': (folder / 'entered.json').exists(),
'result': json.loads(result.read_bytes()) if result.exists() else None, 'current_witness': witness()}
require(p['action'] == 'execute', 'one fixed time contract action')
os.umask(0o077); folder.mkdir(mode=0o700)
create(folder / 'intent.json', enc({key: value for key, value in p.items() if key != 'binary_b64'}))
require(len(p['binary_b64']) == 1559736, 'bounded binary transfer')
raw = base64.b64decode(p['binary_b64'], validate=True)
require(len(raw) == 1169800 and hashlib.sha256(raw).hexdigest() == p['binary_sha256'], 'fixed four-unit binary')
binary = folder / 'time-contract-tests'; create(binary, raw, 0o700)
before = witness(); create(folder / 'before.json', enc(before))
command = ['/usr/bin/setpriv', '--reuid=0', '--regid=0', '--clear-groups', '--no-new-privs', str(binary)]
code, stdout, stderr = run(command + ['--list', '--format', 'terse'])
create(folder / 'list.stdout', stdout); create(folder / 'list.stderr', stderr)
require(code == 0 and stderr == b'', 'native list succeeded')
lines = stdout.decode().splitlines()
require(len(lines) == 4 and sorted(line[:-6] for line in lines if line.endswith(': test')) == p['tests'], 'exact four tests before any run')
create(folder / 'entered.json', enc({'id': ident, 'run_once': True, 'time_ns': time.time_ns()}))
code, stdout, stderr = run(command + ['--test-threads=1', '--nocapture'])
create(folder / 'run.stdout', stdout); create(folder / 'run.stderr', stderr)
after = witness(); create(folder / 'after.json', enc(after))
require(before == after and code == 0 and stderr == b''
and b'4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out' in stdout
and all((b'test ' + name.encode() + b' ... ok') in stdout for name in p['tests']), 'four native units and retained target state')
receipt = dict(id=ident, profile=p['profile'], passed=4, ignored=0, filtered=0, execution_uid=0, tests=p['tests'],
before=before, after=after, binary_sha256=p['binary_sha256'], source_receipt_sha256=p['receipt_sha256'],
source_manifest_sha256=p['manifest_sha256'], stdout_sha256=hashlib.sha256(stdout).hexdigest(),
no_rmm_jobs=True, no_apply=True, no_service_control=True)
create(folder / 'result.json', enc(receipt)); return receipt
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('action', choices=('prepare', 'execute', 'read')); parser.add_argument('--case')
args = parser.parse_args(); os.umask(0o077)
STATE.mkdir(mode=0o700, parents=True, exist_ok=True); support.private(STATE, True)
if args.action == 'prepare':
support.require(args.case is None, 'prepare one new local case')
receipt_path = QUALIFICATION / 'receipt.json'; support.private(receipt_path)
support.require(sha(receipt_path.read_bytes()) == RECEIPT_SHA, 'independently reviewed source receipt')
receipt = support.load(receipt_path); original = support.load(QUALIFICATION / 'inputs.json')
support.require(sha((QUALIFICATION / 'inputs.json').read_bytes()) == INPUTS_SHA
and receipt['inputs_sha256'] == INPUTS_SHA and len(original) == 7
and receipt['result'] == 'LOCAL_RELEASE_PROVIDER4_SOCKET_PERMISSION_FIX_PASS' and receipt['tests'] == 4
and receipt['skips'] == 0 and receipt['filters'] == 0, 'reviewed four-test qualification')
ident = str(uuid.uuid4()); folder = STATE / ident; folder.mkdir(mode=0o700)
copy_exact(receipt_path, folder / 'receipt.json', RECEIPT_SHA, receipt_path.stat().st_size)
copy_exact(QUALIFICATION / 'inputs.json', folder / 'inputs.json', INPUTS_SHA, (QUALIFICATION / 'inputs.json').stat().st_size)
paths = set()
for item in original:
path = Path(item['path'])
support.require(not path.is_absolute() and '..' not in path.parts and str(path) not in paths, 'unique fixed frozen input')
paths.add(str(path)); copy_exact(QUALIFICATION / 'source' / path, folder / 'source' / path, item['sha256'], item['bytes'])
binary = QUALIFICATION / 'qualified-provider-tests'
support.require(receipt['artifacts'][0] == dict(path='qualified-provider-tests', bytes=BINARY_BYTES, sha256=BINARY_SHA), 'fixed original linked artifact')
copy_exact(binary, folder / 'time-contract-tests', BINARY_SHA, BINARY_BYTES)
transports = {path: sha((ROOT / path).read_bytes()) for path in ('deploy/windows_msi_runtime_acceptance.py', 'deploy/vm_access_check.py')}
save_local(folder / 'manifest.json', dict(id=ident, profile=PROFILE, runner_sha256=sha(Path(__file__).read_bytes()),
receipt_sha256=RECEIPT_SHA, binary_sha256=BINARY_SHA, binary_bytes=BINARY_BYTES,
source_files=original, tests=TESTS, transport_sources=transports))
verify_case(folder)
print(json.dumps({'id': ident, 'prepared_locally': True})); return
support.require(args.case is not None, 'original --case required')
ident = str(uuid.UUID(args.case)); support.require(ident == args.case, 'same canonical original case')
folder = STATE / ident; support.private(folder, True); verify_case(folder)
payload = dict(id=ident, action=args.action, profile=PROFILE, tests=TESTS, binary_sha256=BINARY_SHA,
receipt_sha256=RECEIPT_SHA, manifest_sha256=sha((folder / 'manifest.json').read_bytes()),
agent_sha256=AGENT_SHA, helper_sha256=HELPER_SHA)
if args.action == 'execute':
save_local(folder / 'execute-entered.json', {'once': True, 'no_retry': True})
payload['binary_b64'] = base64.b64encode((folder / 'time-contract-tests').read_bytes()).decode()
code = 'import json\n' + inspect.getsource(remote) + '\nprint(json.dumps(remote(' + repr(payload) + ')))\n'
response = support.transport(support.access_settings(ACCESS_ROOT, 'linux'), 'python3 -', code.encode(), folder)
save_local(folder / (args.action + '-' + str(uuid.uuid4()) + '.json'), response)
if args.action == 'read' and response['result'] is not None:
support.require(response['result']['source_manifest_sha256'] == sha((folder / 'manifest.json').read_bytes())
and response['current_witness'] == response['result']['after'], 'same-case retained native result')
print(json.dumps({'id': ident, 'action': args.action, 'passed': response.get('passed'),
'complete': response.get('result') is not None if args.action == 'read' else True, 'read_only': args.action == 'read'}))
if __name__ == '__main__':
main()
+7
View File
@@ -1,5 +1,12 @@
# Übergabe — Linux-MVP abgeschlossen, Windows wird fortgesetzt
**Provider-Socketfix Linux-first bestanden:** Originalfall8ee39b4f, native
Cloud-Linux4/4 ohne Skip/Filter, separater Originalread vollständig; bekannte
Runtimezeugen erhalten.0755 akzeptiert, Gruppen-/Fremdwrite verweigert,
Ancestry/Socket-/Daemon-/Credentialbindung erhalten. [Ergebnis](server-time-source.md).
Keine Chronyrechte geändert und noch keine echte Serverqualitätsprobe.
**Windows-Messfixture eng repariert:** Originalfallefd17b43, separate
SYSTEM-Erstellung mit C#-internem NULL erfolgreich, beide eigenen Messdienste
verifiziert gestoppt; separater Readback und sämtliche RMM-/Serverzeugen erhalten.
+15 -2
View File
@@ -108,8 +108,8 @@ exakt drei tatsächlichen Prozesse seiner festen Cgroup
Chronyd-Kind. Keine zusätzliche oder untergeordnete Cgroup wird übergangen.
Beide Chronyd-Prozesse müssen UID/GID989 und dieselben geschützten
`/usr/sbin/chronyd`-Originalbytes besitzen. Der Root:Root0644-single-link-Pidfile
`/run/chrony/chronyd.pid` bestimmt den Daemon; weil das Verzeichnis UID/GID989
gehört, reicht diese Datei allein ausdrücklich nicht als Namensautorität.
`/run/chrony/chronyd.pid` bestimmt den Daemon; weil das Verzeichnis UID/GID989 und Modus0700
besitzt, reicht diese Datei allein ausdrücklich nicht als Namensautorität.
Zusätzlich muss unter diesen drei Prozessen ausschließlich genau der gewählte
Daemon den tatsächlichen Kernelinode des festen Unix-Datagramsockets
`/run/chrony/chronyd.sock` halten. Diese begrenzte Beobachtung behauptet keine
@@ -301,3 +301,16 @@ werden: der Dateiname `operator.py` darf keine gleichnamigen Python-Standardmodu
gespeichert; unerwartete Fehler liefern nur `unexpected_operator_exception`,
keinen Exceptiontext oder Traceback. Verlorene Antworten erlauben ausschließlich
Lesen des ursprünglichen Falls, keine Phasenwiederholung oder Pinheilung.
Der nachfolgende tatsächliche Preflightfall
`053cfe86` verweigerte allein die zuvor fälschlich erwartete
Chronyverzeichnisberechtigung0755. Der lesende Originalbeleg
`22fa2aabdfdbbd0fe55957358f7f651f317ee647b20a46ab1f2613a365095d7f`
zeigt UID/GID9890700 für `/run/chrony`, Root:Root0644 mit einem Link für die
Pidfile und UID/GID9890755 mit einem Link für den Socket. Der Operator verlangt
jetzt exakt das beobachtete Verzeichnis0700. Der Provider akzeptiert am Socket
Lese-/Ausführungsbits, verweigert weiterhin Gruppen-/Fremdschreibrechte und
behält alle Identitäts-, Ancestry- und Kernelcredentialprüfungen bei. Es wurden
keine Chronyberechtigungen geändert. Beide fehlgeschlagenen Originalfälle bleiben
erhalten; diese Quelle benötigt erneut einen neuen Paket-/Abnahmefall.
+41 -2
View File
@@ -50,8 +50,13 @@ würdigen Pin separat provisionieren und die Providerinstanz neu eröffnen.
Ziel ist ausschließlich `/run/chrony/chronyd.sock`. Seine Identität und
Verzeichniskette werden vor und nach der Abfrage geprüft. Nicht-root-eigene
Verzeichnisse müssen dem gepinnten Chrony-Konto gehören; kein Gruppen- oder
Fremdschreibrecht. Der Socket muss dem gepinnten Daemonkonto gehören und darf
keine Rechte für Fremde haben. Andere Images oder Layouts bleiben vorerst
Fremdschreibrecht. Der Socket muss ein einzelner Socketinode des gepinnten Daemonkontos sein
und darf weder Gruppen- noch Fremdschreibrecht haben. Lese-/Ausführungsbits
wie beim tatsächlich beobachteten Modus0755 verleihen auf Linux kein Recht,
ein Datagramm zu senden; dafür ist Schreibrecht am Pathnamesocket erforderlich
([Linux unix(7)](https://man7.org/linux/man-pages/man7/unix.7.html)). Der Server
verwendet tatsächlich das gehaltene Chronyverzeichnis UID/GID9890700; dessen
Identität sowie sämtliche übrigen Ancestry-/Credentialprüfungen bleiben Pflicht. Andere Images oder Layouts bleiben vorerst
nicht unterstützt, ohne permissiven Fallback.
Der vom Rootoperator separat anzulegende Clientbereich ist
@@ -210,3 +215,37 @@ Socket-Fixtures einschließlich tatsächlicher Namenersetzung/FD-Cleanup.
diesem Lauf.** Der neue native OS-/Validatornachweis ersetzt nicht die offene
reale ARM64-Serverprobe mit provisioniertem Pin und frischer gemeinsamer
Chrony-/Kernelqualität.
## Tatsächlich nativ: Socketberechtigungsfix auf Cloud-Linux
2026-11-15, Originalfall `8ee39b4f-daed-4953-b90f-c04a7b2857c1`:
alle vier vollständig gelisteten Provider-Vertragsprüfungen auf der
tatsächlichen Cloud-Linux-VM als UID0 bestanden,0 fehlgeschlagen,0 ignoriert,
0 gefiltert. Separater Originalfall-Readback vollständig; bekannte Runtimezeugen
vorher/nachher/aktuell unverändert. Der bestehende Sockettest enthält jetzt
ausdrücklich0755 positiv sowie0775/0757 negativ. Root-/Daemonidentitäten,
gehaltene Verzeichnis-/Socketinodes, Singlelink und SCM-Credentials werden
nicht durch eine Berechtigungsausnahme ersetzt. Auf dem Server wurde keine
Chrony-Datei oder -Berechtigung geändert.
Qualifizierte Nativequelle-SHA256
`f1fede6a260c4f91c4bf647f2dcadb63520cdadff22c0130327ecd7cae57921b`.
Lokale eingefrorene Releasequalification7a8cb5be-41b3-400a-bd9b-b4b6f505a6e9,
Receipt-SHA256
`74759e286ba7c9762fe4c455da952a0e62de48f55ea643e0a8f435d2128497a5`,
Sieben-Inputmanifest
`c0067889fa6e79e5b1dc2ad46685613fd0b379b30a4541670f635140405718d9`.
Diese Inputs enthalten auch die zum Freezezeitpunkt gesicherte Dokumentfassung;
nachfolgende Ergebnisdokumentation ist kein Compilerinput. ELF1169800Bytes,
SHA256 `9bd41ff166aeaae45fdf3dda2d72b04fc30e5ef87a181fe733c47e511a836d59`.
Neuer Operator `deploy/time_source_socket_linux_acceptance.py`, SHA256
`eef43096cac8a83751f844d810b97a3f68025786ca64ff34f82be59280ca1aa8`.
Der Lauf verwendet eigene Parser-/Clock-/Socketfixtures. Er öffnet keine
echte NativeTimeSource, fragt weder tatsächliches Chrony noch die Kernelzeit
ab und qualifiziert keinen signierten Zeitanker oder Windowsclock. Reale
Serverprobe und nachfolgender Broker-/mTLS-Roundtrip bleiben offene Schritte.
Ausführungsreceipt-SHA256 `0decb992bfbfa88389da1949fddb491f2ec02a30abc9f4cce886d1f645768e07`.
Separater Rückabruf-SHA256 `88728b6659d506ba96140dd1924a089969e63fcd6f6d308109c4603ec4043da8`.