From 82fefa3298405c67958c837abe82bb6129246178 Mon Sep 17 00:00:00 2001 From: Kevin Janssen Date: Sun, 15 Nov 2026 01:42:08 +0100 Subject: [PATCH] Record real clock bootstrap failures and preserve isolated operators --- deploy/server_time_source_bootstrap.py | 665 ++++++++++++++++++ .../signed_clock_capture_acceptance.py | 510 ++++++++++++++ docs/handover.md | 11 + docs/server-time-source-bootstrap.md | 269 +++++++ docs/windows-signed-clock-capture-operator.md | 159 +++++ 5 files changed, 1614 insertions(+) create mode 100644 deploy/server_time_source_bootstrap.py create mode 100644 deploy/windows/signed_clock_capture_acceptance.py create mode 100644 docs/server-time-source-bootstrap.md create mode 100644 docs/windows-signed-clock-capture-operator.md diff --git a/deploy/server_time_source_bootstrap.py b/deploy/server_time_source_bootstrap.py new file mode 100644 index 0000000..5e7df0f --- /dev/null +++ b/deploy/server_time_source_bootstrap.py @@ -0,0 +1,665 @@ +#!/usr/bin/env python3 +"""Isolated time-source sourcepack and finite operator phases; no SSH/deploy/key setup. + +Host phases are deliberately NOT invoked by prepare. Run them only through the +operator's independently checked server transport. An uncertain phase is read, +never repeated. This first slice does not provision pins, signer, or services. +""" +import argparse +import hashlib +import io +import json +import os +from pathlib import Path +import re +import selectors +import signal +import stat +import struct +import subprocess +import tarfile +import time +import uuid + +ROOT = Path(__file__).resolve().parents[1] +PROFILE = 'rmm.server-time-source.operator.v1' +CRATES = ('time-attestation', 'time-source-linux', 'time-broker-linux') +PACKAGES = tuple('rmm-' + name for name in CRATES) +BUILDER = 'rust:1.99.1-bookworm' +LOCAL_BUILDER = 'sha256:9a76ad3744ebfdddae96ca10001ce8291c1b332fb54c8df5eea0e8e999ac6fc6' +RUNTIME = 'sha256:6f8383f7c762ac77ed1013c94eeafa2b76838c00aec358a375f5847645ea87ec' +HOST_ROOT = Path('/var/lib/rmm-time-source-bootstrap') +PROBE = b'''// Generated operator-only source-quality probe; no signer or caller context. +fn main() { + if std::env::args_os().len() != 1 { std::process::exit(2); } + let result = (|| -> anyhow::Result<()> { + let mut source = rmm_time_source_linux::NativeTimeSource::open()?; + let sample = source.sample()?; + println!("{}", serde_json::json!({ + "profile": "rmm.native-source-quality.once.v1", + "clock_authority": false, "signed_attestation": false, + "captured_utc_ns": sample.captured_utc_ns(), + "server_error_ns": sample.server_error_ns(), + "source_sync_age_ns": sample.source_sync_age_ns(), + "server_boot_id": sample.server_boot_id(), + "captured_monotonic_ns": sample.captured_monotonic_ns(), + "sampled_boottime_ns": sample.sampled_boottime_ns(), + "kernel_state": sample.kernel_state() + })); + Ok(()) + })(); + if result.is_err() { eprintln!("TIME_SOURCE_OPERATOR_PROBE_DENIED"); std::process::exit(1); } +} +''' + + +def require(ok, reason): + if not ok: + raise RuntimeError(reason) + + +def digest(raw): + return hashlib.sha256(raw).hexdigest() + + +def encoded(value): + return (json.dumps(value, sort_keys=True, separators=(',', ':')) + '\n').encode() + + +def identifier(value): + require(str(uuid.UUID(value)) == value and uuid.UUID(value).version == 4, 'canonical UUIDv4 case') + return value + + +def exclusive(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_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW) + try: + os.fsync(fd) + finally: + os.close(fd) + + +def regular(path, limit=16 * 1024 * 1024, single_link=True): + fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW) + with os.fdopen(fd, 'rb') as stream: + before = os.fstat(stream.fileno()) + require(stat.S_ISREG(before.st_mode) and (not single_link or before.st_nlink == 1) and before.st_size <= limit, + 'bounded single-link regular file') + raw = stream.read(limit + 1) + after = os.fstat(stream.fileno()) + stable = lambda item: (item.st_dev, item.st_ino, item.st_uid, item.st_gid, item.st_mode, + item.st_nlink, item.st_size, item.st_mtime_ns, item.st_ctime_ns) + require(len(raw) <= limit and stable(before) == stable(after), 'stable bounded input') + return raw + + +def run(args, timeout=15, limit=1024 * 1024): + # Fixed commands only; no shell, environment/configuration interpolation. + result = subprocess.run(args, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, + stderr=subprocess.PIPE, timeout=timeout, check=False) + require(len(result.stdout) <= limit and len(result.stderr) <= limit, 'bounded command output') + require(result.returncode == 0, 'fixed command failed: ' + args[0]) + return result.stdout + + +def package_identity(package): + return tuple(package.get(key) for key in ('name', 'version', 'source', 'checksum')) + + +def lock_package(block): + """Fail-closed reader for Cargo's canonical lock-v4 package blocks, not TOML in general.""" + value, dependencies, inside = {}, [], False + for line in block.strip().splitlines(): + if inside: + if line == ']': + inside = False + else: + require(line.startswith(' "') and line.endswith('",'), 'canonical lock dependency line') + dependencies.append(json.loads(line.strip()[:-1])) + elif line == 'dependencies = [': + require('dependencies' not in value, 'unique dependency array') + value['dependencies'] = dependencies + inside = True + else: + match = re.fullmatch(r'(name|version|source|checksum) = ("[^"\\]*")', line) + require(match and match[1] not in value, 'canonical unique lock package field') + value[match[1]] = json.loads(match[2]) + require(not inside and 'name' in value and 'version' in value, 'complete lock package') + if 'source' in value: + require(value['source'] == 'registry+https://github.com/rust-lang/crates.io-index' and + re.fullmatch('[0-9a-f]{64}', value.get('checksum', '')), 'locked crates.io checksum only') + return value + + +def subset_lock(raw): + """Preserve exact original lock blocks, selecting their dependency closure.""" + blocks = raw.decode().split('[[package]]') + require(blocks[0] == '# This file is automatically @generated by Cargo.\n' + '# It is not intended for manual editing.\nversion = 4\n\n', 'canonical Cargo lock v4 header') + packages = [lock_package(block) for block in blocks[1:]] + by_name = {} + for item in packages: + by_name.setdefault(item['name'], []).append(item) + held = {} + + def visit(item): + identity = package_identity(item) + if identity in held: + return + held[identity] = item + for dependency in item.get('dependencies', []): + parts = dependency.split(' ') + matches = by_name[parts[0]] + if len(parts) > 1: + matches = [value for value in matches if value['version'] == parts[1]] + if len(parts) > 2: + matches = [value for value in matches if '(' + value.get('source', '') + ')' == parts[2]] + require(len(matches) == 1, 'unambiguous locked dependency') + visit(matches[0]) + + for name in PACKAGES: + matches = by_name[name] + require(len(matches) == 1 and 'source' not in matches[0], 'exact workspace package') + visit(matches[0]) + selected = [block for block in blocks[1:] + if package_identity(lock_package(block)) in held] + output = (blocks[0] + ''.join('[[package]]' + block for block in selected)).encode() + require({package_identity(lock_package(p)) for p in output.decode().split('[[package]]')[1:]} == set(held), + 'exact lock closure, no version/checksum changes') + return output + + +def workspace_recipe(root_raw): + """Reuse original workspace values verbatim; only members/dependency set shrink.""" + deps = ('anyhow', 'hex', 'rand', 'serde', 'serde_json', 'sha2', 'uuid') + lines = root_raw.decode().splitlines() + start = lines.index('[workspace.package]') + end = lines.index('[workspace.dependencies]') + package = '\n'.join(lines[start:end]).strip() + dependency_lines = [] + for name in deps: + selected = [line for line in lines[end + 1:] if line.startswith(name + ' = ')] + require(len(selected) == 1, 'single original workspace dependency') + dependency_lines.extend(selected) + recipe = ('[workspace]\nresolver = "2"\nmembers = ' + + json.dumps(['crates/' + name for name in CRATES]) + '\n\n' + package + + '\n\n[workspace.dependencies]\n' + '\n'.join(dependency_lines) + '\n').encode() + return recipe + + +def compare_lock(original, generated): + original_blocks = original.decode().split('[[package]]') + generated_blocks = generated.decode().split('[[package]]') + require(original_blocks[0] == generated_blocks[0], 'same canonical lock version') + known = {package_identity(lock_package(block)) for block in original_blocks[1:]} + selected = [lock_package(block) for block in generated_blocks[1:]] + require(len(selected) == len({package_identity(item) for item in selected}) and + all(package_identity(item) in known for item in selected), + 'every generated package version/source/checksum exists in public original lock') + require({item['name'] for item in selected if 'source' not in item} == set(PACKAGES), + 'only three original workspace packages') + return len(selected) + + +def generate_lock(case, payload, original): + workspace = case / 'lock-workspace' + workspace.mkdir(mode=0o700) + for name, raw in payload.items(): + path = workspace / name + path.parent.mkdir(mode=0o700, parents=True, exist_ok=True) + exclusive(path, raw) + args = ['docker', 'run', '--rm', '--pull=never', '--network=none', '--read-only', + '--tmpfs=/tmp:rw,nosuid,nodev,size=64m', '--cap-drop=ALL', + '--security-opt=no-new-privileges', '--user', f'{os.getuid()}:{os.getgid()}', + '-v', str(workspace) + ':/src:rw', '--entrypoint=cargo', LOCAL_BUILDER, + 'generate-lockfile', '--manifest-path', '/src/Cargo.toml', '--offline'] + result = subprocess.run(args, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, timeout=120, check=False) + require(len(result.stdout) <= 1024 * 1024, 'bounded local Cargo lock generation output') + exclusive(case / 'lock-generation.log', result.stdout) + require(result.returncode == 0, 'local offline lock generation failed; retained original case log') + os.chmod(workspace / 'Cargo.lock', 0o600) + generated = regular(workspace / 'Cargo.lock') + count = compare_lock(original, generated) + # Cargo was allowed to alter only the generated lock file in this private recipe. + for name, raw in payload.items(): + if name != 'Cargo.lock': + require(regular(workspace / name) == raw, 'original copied source unchanged by lock generation') + return generated, {'builder_image': LOCAL_BUILDER, 'offline': True, + 'package_count': count, 'log_sha256': digest(result.stdout)} + + +def prepare(commit): + require(re.fullmatch('[0-9a-f]{40}', commit) is not None, 'full public source commit') + public = run(['git', '-C', str(ROOT), 'for-each-ref', '--format=%(objectname)', 'refs/remotes/origin/']).decode().splitlines() + require(commit in public, 'checkpoint must be an already fetched origin branch tip') + names = run(['git', '-C', str(ROOT), 'ls-tree', '-r', '--name-only', commit]).decode().splitlines() + inputs = ['Cargo.toml', 'Cargo.lock', 'rust-toolchain.toml'] + inputs += [name for name in names if any(name == f'crates/{crate}/Cargo.toml' or + (name.startswith(f'crates/{crate}/src/') and name.endswith('.rs')) for crate in CRATES)] + require(len(inputs) >= 12 and len(inputs) <= 24, 'bounded complete three-crate source set') + source = {} + for name in sorted(inputs): + raw = run(['git', '-C', str(ROOT), 'show', commit + ':' + name]) + require(regular(ROOT / name) == raw, 'working input differs from public checkpoint: ' + name) + source[name] = raw + payload = dict(source) + payload['Cargo.toml'] = workspace_recipe(source['Cargo.toml']) + payload['Cargo.lock'] = subset_lock(source['Cargo.lock']) + payload['crates/time-source-linux/examples/operator_probe.rs'] = PROBE + state = ROOT / 'devstate/server-time-source-bootstrap' + state.mkdir(parents=True, mode=0o700, exist_ok=True) + require(state.stat().st_uid == os.getuid() and stat.S_IMODE(state.stat().st_mode) == 0o700, + 'private local case root') + case = state / str(uuid.uuid4()) + case.mkdir(mode=0o700) + payload['Cargo.lock'], lock_proof = generate_lock(case, payload, source['Cargo.lock']) + # Provenance originals are not compiled, but their exact bytes travel with the pack. + for name in ('Cargo.toml', 'Cargo.lock'): + payload['provenance/' + name] = source[name] + manifest = {'profile': PROFILE, 'public_commit': commit, 'builder': BUILDER, + 'operator_sha256': digest(Path(__file__).read_bytes()), + 'lock_generation': lock_proof, + 'source_files': [{'path': name, 'bytes': len(raw), 'sha256': digest(raw)} + for name, raw in sorted(source.items())], + 'package_files': [{'path': name, 'bytes': len(raw), 'sha256': digest(raw)} + for name, raw in sorted(payload.items())], + 'probe_only': True, 'provisioned': False} + payload['manifest.json'] = encoded(manifest) + buffer = io.BytesIO() + with tarfile.open(fileobj=buffer, mode='w', format=tarfile.USTAR_FORMAT) as archive: + for name, raw in sorted(payload.items()): + item = tarfile.TarInfo(name) + item.size, item.mode, item.uid, item.gid, item.mtime = len(raw), 0o600, 0, 0, 0 + archive.addfile(item, io.BytesIO(raw)) + exclusive(case / 'source.tar', buffer.getvalue()) + exclusive(case / 'operator.py', Path(__file__).read_bytes()) + exclusive(case / 'manifest.json', encoded(manifest)) + receipt = {'case': case.name, 'source_tar_sha256': digest(buffer.getvalue()), + 'source_tar_bytes': len(buffer.getvalue()), 'manifest_sha256': digest(encoded(manifest)), + 'compiled': False, 'target_executed': False} + exclusive(case / 'prepared.json', encoded(receipt)) + print(json.dumps({'path': str(case), **receipt}, sort_keys=True)) + + +def protected_dir(path, create=False): + require(path.is_absolute(), 'absolute fixed operator path') + current = Path('/') + for part in path.parts[1:]: + current /= part + if create and not current.exists(): + current.mkdir(mode=0o700) + info = current.lstat() + require(stat.S_ISDIR(info.st_mode) and info.st_uid == 0 and info.st_mode & 0o022 == 0, + 'root-owned protected directory ancestry') + return path + + +def host_case(value, create=False): + require(os.geteuid() == 0 and os.uname().sysname == 'Linux' and os.uname().machine == 'aarch64', + 'root Linux ARM64 server only') + protected_dir(HOST_ROOT, create=create) + path = HOST_ROOT / identifier(value) + if create: + path.mkdir(mode=0o700) + protected_dir(path) + require(stat.S_IMODE(path.stat().st_mode) == 0o700, 'private operator case') + return path + + +def metadata(path): + item = path.lstat() + return {key: getattr(item, 'st_' + key) for key in ('dev', 'ino', 'uid', 'gid', 'mode', 'size', 'mtime_ns', 'ctime_ns')} + + +def runtime_witness(): + names = ('gateway', 'api', 'postgres') + result = {} + for name in names: + container = 'rust-discovery-server-' + name + '-1' + # Never inspect Env, command arguments, health output, mounts or credentials. + raw = run(['docker', 'inspect', '--format', + '{{json .Image}} {{json .Config.User}} {{json .State.Running}} {{json .State.Pid}} {{json .State.StartedAt}} {{json .RestartCount}} {{json .NetworkSettings.Ports}}', container]) + # Multiple JSON values are deliberately decoded separately (spaces inside quoted dates/users are safe). + decoder, values, text = json.JSONDecoder(), [], raw.decode().strip() + while text: + value, end = decoder.raw_decode(text) + values.append(value) + text = text[end:].lstrip() + require(len(values) == 7 and values[2] is True and values[3] > 1, 'live expected runtime container') + if name != 'postgres': + require(values[0] == RUNTIME and values[1] == '10001:10001', 'fixed runtime image and user') + for bindings in (values[6] or {}).values(): + require(bindings is None or (name != 'postgres' and all(x['HostIp'] == '127.0.0.1' for x in bindings)), + 'no public Docker port or PostgreSQL publication') + result[name] = values + return result + + +def preflight(): + engine = run(['docker', 'version', '--format', '{{json .Server.Version}}']).decode().strip() + image_values = json.loads(run(['docker', 'image', 'inspect', '--format', + '[{{json .Id}},{{json .Architecture}},{{json .Os}}]', BUILDER])) + image = dict(zip(('Id', 'Architecture', 'Os'), image_values, strict=True)) + # Inspect only public immutable image metadata, never Config/Env. + require(image['Architecture'] == 'arm64' and image['Os'] == 'linux', 'cached ARM64 builder required') + pid = int(run(['systemctl', 'show', 'chrony.service', '--property=MainPID', '--value']).strip()) + require(pid > 1, 'existing Chrony service PID') + proc = Path('/proc') / str(pid) + pidfd = os.pidfd_open(pid) + try: + status = regular(proc / 'status', 65536).decode() + ids = {} + for label in ('Uid', 'Gid'): + match = re.search('^' + label + r':\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)$', status, re.MULTILINE) + require(match and len(set(match.groups())) == 1, 'fixed real/effective daemon IDs') + ids[label.lower()] = int(match[1]) + birth = regular(proc / 'stat', 8192).decode().rsplit(')', 1)[1].split()[19] + image_path = Path('/usr/sbin/chronyd') + fixed = metadata(image_path) + require(stat.S_ISREG(fixed['mode']) and fixed['uid'] == 0 and fixed['mode'] & 0o022 == 0, + 'protected Chrony executable') + require(os.stat(proc / 'exe').st_ino == fixed['ino'] and os.stat(proc / 'exe').st_dev == fixed['dev'], + 'actual daemon fixed executable inode') + image_hash = digest(regular(image_path)) + require(metadata(image_path) == fixed and + regular(proc / 'stat', 8192).decode().rsplit(')', 1)[1].split()[19] == birth and + int(run(['systemctl', 'show', 'chrony.service', '--property=MainPID', '--value']).strip()) == pid, + 'Chrony identity unchanged during probe') + poll = __import__('select').poll() + poll.register(pidfd, __import__('select').POLLIN) + require(not poll.poll(0), 'Chrony process still alive') + finally: + os.close(pidfd) + boot = regular(Path('/proc/sys/kernel/random/boot_id'), 128).decode().strip() + require(str(uuid.UUID(boot)) == boot, 'kernel boot identity') + return {'docker_engine_version': json.loads(engine), + 'builder': {key: image[key] for key in ('Id', 'Architecture', 'Os')}, + 'runtime': runtime_witness(), 'boot_id': boot, + 'chrony_observation': {'schema_version': 1, 'daemon_pid': pid, + 'daemon_birth_ticks': int(birth), 'daemon_uid': ids['uid'], 'daemon_gid': ids['gid'], + 'daemon_image_sha256': image_hash}, + 'chrony_image_metadata': fixed, 'pins_provisioned': False, + 'quality_sampled': False, 'registry_cache_verified': False} + + +def unpack(case, expected): + require(re.fullmatch('[0-9a-f]{64}', expected) is not None, 'exact operator-approved source hash') + raw = regular(case / 'source.tar', 2 * 1024 * 1024) + require(digest(raw) == expected, 'exact uploaded source archive') + files = {} + with tarfile.open(fileobj=io.BytesIO(raw), mode='r:') as archive: + for member in archive.getmembers(): + require(member.isfile() and member.name not in files and member.size <= 1024 * 1024 + and not Path(member.name).is_absolute() and '..' not in Path(member.name).parts, + 'bounded regular unique archive entries') + files[member.name] = archive.extractfile(member).read() + require(len(files) <= 30 and 'manifest.json' in files, 'bounded source archive manifest') + manifest = json.loads(files['manifest.json']) + require(manifest['profile'] == PROFILE and manifest['builder'] == BUILDER and + manifest['operator_sha256'] == digest(Path(__file__).read_bytes()), 'reviewed operator profile') + require(set(files) == {'manifest.json'} | {x['path'] for x in manifest['package_files']}, 'exact manifest file set') + originals = {x['path']: x for x in manifest['source_files']} + for item in manifest['package_files']: + require(len(files[item['path']]) == item['bytes'] and digest(files[item['path']]) == item['sha256'], + 'every source package hash and length') + for name, item in originals.items(): + actual = files['provenance/' + name] if name in ('Cargo.toml', 'Cargo.lock') else files[name] + require(len(actual) == item['bytes'] and digest(actual) == item['sha256'], 'unchanged original checkpoint input') + require(files['Cargo.toml'] == workspace_recipe(files['provenance/Cargo.toml']) and + compare_lock(files['provenance/Cargo.lock'], files['Cargo.lock']) == manifest['lock_generation']['package_count'] and + manifest['lock_generation']['builder_image'] == LOCAL_BUILDER and + manifest['lock_generation']['offline'] is True and + files['crates/time-source-linux/examples/operator_probe.rs'] == PROBE, + 'exact generated recipe, lock closure, source-only probe') + destination = case / 'workspace' + destination.mkdir(mode=0o700) + for name, value in sorted(files.items()): + target = destination / name + target.parent.mkdir(parents=True, exist_ok=True, mode=0o700) + exclusive(target, value) + return {'source_tar_sha256': expected, 'manifest_sha256': digest(files['manifest.json']), + 'public_commit': manifest['public_commit'], 'package_files': manifest['package_files']} + + +def verify_workspace(case): + staged = json.loads(regular(case / 'stage' / 'result.json')) + for item in staged['package_files']: + raw = regular(case / 'workspace' / item['path']) + require(digest(raw) == item['sha256'] and len(raw) == item['bytes'], 'original staged source bytes') + return staged + + +def long_command(args, log, timeout, cancel=None): + fd = os.open(log, os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW | os.O_WRONLY, 0o600) + with os.fdopen(fd, 'wb') as stream: + process = subprocess.Popen(args, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, + start_new_session=True) + deadline, written = time.monotonic() + timeout, 0 + try: + with selectors.DefaultSelector() as selector: + selector.register(process.stdout, selectors.EVENT_READ) + while selector.get_map(): + remaining = deadline - time.monotonic() + require(remaining > 0, 'bounded command timeout; read original case only') + events = selector.select(remaining) + require(events, 'bounded command timeout; read original case only') + raw = os.read(process.stdout.fileno(), 65536) + if not raw: + selector.unregister(process.stdout) + break + allowed = 8 * 1024 * 1024 - written + stream.write(raw[:allowed]) + written += min(len(raw), allowed) + require(len(raw) <= allowed, 'bounded command output exceeded; read original case only') + remaining = deadline - time.monotonic() + require(remaining > 0, 'bounded command timeout; read original case only') + code = process.wait(timeout=remaining) + except BaseException: + # The leader is still our unreaped child: its process group cannot + # have been recycled to an unrelated process. + if process.returncode is None: + try: + os.killpg(process.pid, signal.SIGKILL) + except ProcessLookupError: + pass + process.wait() + if cancel is not None: + cancel() + raise + finally: + process.stdout.close() + stream.flush() + os.fsync(stream.fileno()) + return code + + +def cancel_owned_builder(cidfile, image_id, case_id): + # No name-based/global docker kill. Missing/uncertain identity is reported; + # the independent in-container 850s timeout remains the final bound. + if not cidfile.exists(): + raise RuntimeError('no retained container ID; read original case, internal timeout remains') + cid = regular(cidfile, 128).decode().strip() + require(re.fullmatch('[0-9a-f]{64}', cid) is not None, 'exact own Docker container ID') + inspected = subprocess.run(['docker', 'inspect', '--format', + '[{{json .Id}},{{json .Image}},{{json .Name}},{{json (index .Config.Labels "rmm.time-source.case")}},{{json .State.Running}}]', cid], + stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, timeout=10, check=False) + if inspected.returncode != 0: + # --rm may already have removed our completed container. No fallback. + return + require(len(inspected.stdout) <= 4096, 'bounded own container metadata') + identity = json.loads(inspected.stdout) + require(identity[:4] == [cid, image_id, '/rmm-time-source-build-' + case_id, case_id], + 'exact retained own container/image/case identity before cancellation') + if identity[4] is True: + run(['docker', 'kill', '--signal=KILL', cid], timeout=10, limit=4096) + + +def elf(path): + raw = regular(path, 32 * 1024 * 1024) + require(raw[:6] == b'\x7fELF\x02\x01' and struct.unpack('= before['sequence'], 'all six native fields and journal identity/schema/core counts preserved') + + +def baseline(access, folder): + save(folder / 'baseline-attempt.json', dict(read_only=True)) + server = server_closed(access); native = native_witness(access) + save(folder / 'baseline.json', dict(server=server, native=native, indices=INDEX_SHAS)) + print(json.dumps(dict(id=folder.name, baseline_read_only=True))) + + +def payload(folder, manifest, phase): + return dict(id=folder.name, profile=PROFILE, action=phase, exe_sha256=EXE_SHA, exe_bytes=EXE_BYTES, + script_sha256=manifest['script_sha256'], manifest_sha256=sha(folder / 'manifest.json')) + + +def validate_role(role, value, ident): + require(role in ('local-service', 'system'), 'fixed role validation') + report = value['reports']['report']; end = value['reports']['end']; intent = value['reports']['intent'] + outcome = value['markers']['outcome']; exited = value['markers']['exit']; process = value['markers']['process'] + require(report is not None and end is not None and outcome is not None and exited is not None and process is not None + and outcome['success'] is True and end['success'] is True and exited['kernel_process_exited'] is True + and exited['exit_code'] == 0 and exited['timed_out'] is False and exited['scm_exit'] == exited['scm_specific_exit'] == 0 + and report['role'] == end['role'] == role and report['case_id'] == end['case_id'] == intent['case_id'] == ident + and value['raw_report_sha256'] == end['report_sha256'] == outcome['report_sha256'] and report['pid'] == intent['pid'] == process['proof']['pid'] + and str(report['process_birth_filetime']) == process['proof']['creation_filetime'] + and report['image_sha256'] == EXE_SHA and report['calibrated'] is report['clock_authority'] is False, + 'actual own role/process/end/exit proof') + expected = 'S-1-5-19' if role == 'local-service' else 'S-1-5-18' + require(report['token']['user_sid'] == process['proof']['owner_sid'] == expected + and report['token']['service_sid_sha256'] == hashlib.sha256(process['proof']['service_sid'].encode()).hexdigest() + and process['proof']['service_sid_enabled'] is True and process['proof']['kernel_handle_bound'] is True, + 'actual token and enabled own service SID') + capture = report['capture']; rows = capture['samples_100ns'] + require(capture['schema_version'] == 1 and capture['calibrated'] is capture['clock_authority'] is False + and capture['sample_count'] == len(rows) == 128 and capture['elapsed_monotonic_ns'] <= 250_000_000 + and capture['elapsed_interrupt_ns'] <= 250_000_000 and all(isinstance(row, list) and len(row) == 5 + and all(type(number) is int and 0 <= number < 2**64 for number in row) for row in rows), 'bounded numeric raw capture, never calibration') + if value['service'] is None: + require(value['markers']['delete-attempt'] is not None and value['markers']['deleted']['service_absent'] is True, 'original own cleanup and actual absence') + else: + require(value['status'] is not None and value['status']['State'] == 1 and value['status']['Pid'] == 0, 'own service stopped') + + +def read(access, folder, manifest): + read_id = str(uuid.uuid4()) + raw_path = folder / ('read-' + read_id + '.json') + server_path = folder / ('read-server-' + read_id + '.json') + native_path = folder / ('read-native-' + read_id + '.json') + preservation_path = folder / ('read-preservation-' + read_id + '.json') + receipt_path = folder / ('read-receipt-' + read_id + '.json') + response = access.powershell(LAUNCH, payload(folder, manifest, 'read'), timeout=90) + # Save/fsync the exact canonical raw read before creating any linked proof. + save(raw_path, response) + raw_link = dict(filename=raw_path.name, sha256=sha(raw_path)) + binding = dict(case_id=folder.name, read_id=read_id, raw_read_filename=raw_path.name, + raw_read_sha256=raw_link['sha256'], runner_sha256=sha(__file__), + controller_sha256=manifest['script_sha256'], read_only=True) + completed = [] + for role, value in response.get('roles', {}).items(): + if value['markers']['outcome'] is not None: + validate_role(role, value, folder.name) + completed.append(role) + old = load(folder / 'baseline.json') + server = server_closed(access); native = native_witness(access) + require(server == old['server'], 'current server gates unchanged') + preserved(old['native'], native) + # Each independently captured witness binds this exact same saved read. + save(server_path, dict(binding, witness=server)) + save(native_path, dict(binding, witness=native)) + server_link = dict(filename=server_path.name, sha256=sha(server_path)) + native_link = dict(filename=native_path.name, sha256=sha(native_path)) + cleaned = sorted(role for role, value in response.get('roles', {}).items() if value['service'] is None and value['markers']['deleted'] is not None and value['markers']['deleted']['service_absent'] is True) + save(preservation_path, dict(binding, server=server, native=native, + server_witness=server_link, native_witness=native_link, + completed_roles=sorted(completed), cleanup_verified_roles=cleaned, + calibrated=False, clock_authority=False)) + preservation_link = dict(filename=preservation_path.name, sha256=sha(preservation_path)) + # Final create-only receipt is published only after A, both witnesses and B + # have been persisted. Missing files never become a completed read receipt. + save(receipt_path, dict(binding, schema_version=1, raw_read=raw_link, + preservation=preservation_link, server_witness=server_link, + native_witness=native_link, calibrated=False, clock_authority=False)) + print(json.dumps(dict(id=folder.name, read_only=True, completed_roles=sorted(completed), + read_receipt_filename=receipt_path.name, read_receipt_sha256=sha(receipt_path)))) + + +def mutate(access, folder, manifest, phase): + old = load(folder / 'baseline.json') + require(server_closed(access) == old['server'], 'same closed server before action') + preserved(old['native'], native_witness(access)) + if phase != 'setup': + require((folder / 'setup-reply.json').exists(), 'one completed original setup') + if phase.startswith('start-'): + require(not any(folder.glob('cleanup-*-attempt.json')), 'cleanup already began; no new starts') + save(folder / (phase + '-attempt.json'), dict(id=folder.name, once=True, no_retry=True)) + if phase == 'setup': + access.stage_capture(folder / 'SignedClockCapture.exe', 'SignedClockCapture.exe') + access.stage_capture(folder / 'SignedClockCaptureAcceptance.ps1', 'SignedClockCaptureAcceptance.ps1') + observed = access.powershell(LAUNCH, payload(folder, manifest, phase), timeout=90) + save(folder / (phase + '-reply.json'), observed) + require(observed['id'] == folder.name and observed['calibrated'] is observed['clock_authority'] is False, 'original non-authoritative native response') + if phase.startswith('start-'): + validate_role(phase.removeprefix('start-'), observed['roles'][phase.removeprefix('start-')], folder.name) + if phase.startswith('cleanup-'): + role = phase.removeprefix('cleanup-') + require(observed['roles'][role]['service'] is None and observed['roles'][role]['markers']['deleted']['service_absent'] is True, + 'exact own stopped service deleted once and absence observed') + after_server = server_closed(access); after_native = native_witness(access) + require(after_server == old['server'], 'current server policy/counts/hooks unchanged') + preserved(old['native'], after_native) + save(folder / (phase + '-preserved.json'), dict(server=after_server, native=after_native, no_rmm_jobs=True)) + print(json.dumps(dict(id=folder.name, phase=phase, preserved=True, calibrated=False, clock_authority=False))) + + +def static_guards(): + require(SCRIPT.count('$h.StartOnce()') == SCRIPT.count('$h.DeleteOnce()') == SCRIPT.count('[RmmCaptureControl]::KillHeld($process)') == 1, 'single fixed own action primitives') + require(all(token not in SCRIPT for token in ('RmmDiscoveryWindows', 'RmmDiscoverySystemHelper', 'device.key', 'Restart-Service', 'Restart-Computer', 'Stop-Computer', 'Set-Date', 'w32tm', 'Invoke-Expression', 'Bypass')), 'no RMM/W32Time/setter/general execution path') + require('function FileIdentity' not in NATIVE and 'function ActualState' not in NATIVE and 'function Swap' not in NATIVE, 'only original read-only handle proof reused') + require(len(SCRIPT.encode()) <= 65536 and len(base64.b64encode(LAUNCH.encode('utf-16le'))) + 2048 < 32767, 'bounded staged controller and launch command') + + +def main(): + os.umask(0o077) + static_guards() + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('phase', choices=('prepare', 'baseline', 'setup', 'start-local-service', 'start-system', 'read', 'cleanup-local-service', 'cleanup-system')) + parser.add_argument('--case') + args = parser.parse_args() + if args.phase == 'prepare': + require(args.case is None, 'one new local campaign only'); prepare(); return + require(args.case is not None, 'original case required') + folder, manifest = case(args.case) + access = CaptureAccess(ACCESS_ROOT) + if args.phase == 'baseline': + baseline(access, folder) + elif args.phase == 'read': + read(access, folder, manifest) + else: + mutate(access, folder, manifest, args.phase) + + +if __name__ == '__main__': + main() diff --git a/docs/handover.md b/docs/handover.md index dadd4a6..1df7cbb 100644 --- a/docs/handover.md +++ b/docs/handover.md @@ -1,5 +1,16 @@ # Übergabe — Linux-MVP abgeschlossen, Windows wird fortgesetzt +**Native Zeitbootstrapversuche2026-11-15:** Windowsoriginalfall efd17b43 +baseline und AST/C# compile-only bestanden; Setup bei zweiter Messdienstanlage +gescheitert. Eigener LocalService gestoppt, SYSTEM fehlt; Originalread samt +RMM-/Servererhaltung vollständig. Keine Rollenstarts/Calibration. Serverfall +d3be954b scheitert an unzutreffender MainPID==chronyd-Annahme; Shellwrapper +und zwei chronyd-Prozesse tatsächlich lesend belegt. Kein Stage/Build/Probe, +Pin oder Runtimewechsel. Einzelheiten: [Windowsoperator](windows-signed-clock-capture-operator.md) +und [Serveroperator](server-time-source-bootstrap.md). Originale bleiben erhalten, +kein ungeprüfter Retry. Windows-MVP weiterhin offen. + + **Rohcapturequellen Linux-first bestanden, noch keine Windowsuhr:** dcef489d, volle15er-Liste, neue5Guards bestanden/10andere gefiltert, separater Rückabruf vollständig. [Belege](windows-signed-clock-capture.md). Broker3lokaleGuards, diff --git a/docs/server-time-source-bootstrap.md b/docs/server-time-source-bootstrap.md new file mode 100644 index 0000000..9325684 --- /dev/null +++ b/docs/server-time-source-bootstrap.md @@ -0,0 +1,269 @@ +# Isoliertes ARM64-Quellenpaket für den Zeitprovider + +Dieser Schnitt liefert einen konkreten Paketbauer und begrenzte Operatorphasen +in `deploy/server_time_source_bootstrap.py`. Er installiert keinen Broker, +erzeugt keine Schlüssel oder Chrony-Pins und verändert keine RMM-Konfiguration. +Der öffentliche Quellencheckpoint ist +`2dfd791aa5703f42f0258d17bc9b5f6c9d71337f`. Native Serverabnahme, tatsächliche +Quellqualität, Socket-Namespaceprofil und HTTP-Inbetriebnahme bleiben getrennte +offene Schritte. Die WebUI-Genehmigungsgrenze für sämtliche RMM-Jobs bleibt erhalten. + +## Paket und Herkunft + +`prepare --commit ` arbeitet ausschließlich lokal. Der Commit +muss als bereits vorhandener `origin`-Branch-Tip belegt sein. Alle drei +Zeitcrates einschließlich ihrer Manifeste und Rustquellen werden bytegleich +gegen diesen Commit und den Arbeitsbaum verglichen. Andere Workspacecrates, +`credentials/`, `devstate/`, Konfigurationen und Schlüssel kommen nicht ins +Archiv. Originales Workspace-Manifest und Lockfile reisen als Herkunftsbelege mit. + +Das generierte Workspace-Manifest verkleinert nur die Member-/Dependencyliste; +Paketdaten und benutzte Dependencydefinitionen bleiben im Originalwortlaut. +Ein gesonderter lokaler, netzloser Rust-1.99.1-Container erzeugt tatsächlich das +Teil-Lockfile. Jede erzeugte Paketidentität aus Name, Version, Quelle und +Checksum muss im öffentlichen Original-Lock vorkommen; Versionsänderungen +verweigern. Der begrenzte Reader akzeptiert ausschließlich das aktuelle +kanonische Cargo-Lock-v4-Format und crates.io-Checksums. Neue Formate oder +Gitdependencies benötigen eine ausdrückliche Quelländerung. Anschließend +wird nur mit `--locked` gebaut. Das Repository-Lockfile wird nicht verändert. + +Nur im Paket kommt das feste Example `operator_probe.rs` hinzu. Es akzeptiert +keine Argumente, öffnet die echte `NativeTimeSource` und erfasst genau ein +Sample. Die Ausgabe enthält ausschließlich numerische Zeit-/Fehler-/Alterswerte, +Boot-ID und feste Kennzeichnungen `clock_authority=false` und +`signed_attestation=false`. Kein Signer, Schlüssel, frei wählbarer Context, +Grant, Clocksetter oder Jobpfad. Ein Fehler liefert nur die feste Meldung +`TIME_SOURCE_OPERATOR_PROBE_DENIED`. + +## Getrennte Operatorphasen + +Die folgenden Befehle sind Bedienung des implementierten Werkzeugs und **keine +Behauptung bereits ausgeführter Serveraktionen**. Das Werkzeug besitzt keine +SSH-Funktion. Der Rootoperator prüft seinen Transport, den Operatorhash und den +Archivhash separat. Ein neuer kanonischer UUIDv4-Fall liegt ausschließlich unter +`/var/lib/rmm-time-source-bootstrap/` mit Root0700; jede Phase erzeugt ein +eigenes Verzeichnis, einen create-only Intent und anschließend ein Ergebnis. +Vorhandene Verzeichnisse/Intents werden nie wiederverwendet. Nach verlorener +Antwort ausschließlich `host-read --case ` benutzen, keine Wiederholung. + +1. Lokal: `python3 deploy/server_time_source_bootstrap.py prepare --commit + 2dfd791aa5703f42f0258d17bc9b5f6c9d71337f`. Das Ergebnis nennt den privaten + Fallpfad sowie Hash und Länge des Archivs. Auch ein fehlgeschlagener lokaler + Lockversuch bleibt als eigener Fall erhalten. +2. Auf dem Server separat: `host-preflight --case `. Dies erzeugt nur den + Operatorfall und liest begrenzte Metadaten. Danach lädt der Operator genau + dieses `operator.py` und `source.tar` create-only in diesen Fall. Keine + automatische Übertragung, kein Überschreiben bestehender Dateien. +3. `host-stage --case --sha256 ` prüft jede Länge und jeden + Hash vor eigener manueller Extraktion. Keine Tar-Symlinks, Hardlinks, + absoluten Pfade oder `..`; keine Extraktion unter `/opt/rust-discovery`. +4. `host-build --case ` benutzt ausschließlich das vorhandene ARM64-Image + `rust:1.99.1-bookworm`, dessen gespeicherte immutable Image-ID aus dem + ursprünglichen Preflight, und + `--pull=never --network none --locked --offline`. Der Quellmount ist lesend, + Targetmount ausschließlich dieser Fall. Keine OS-Pakete oder Installertools. + Ein eigener Containername, eine interne feste 850s-Deadline und ein äußerer + 900s-Wächter begrenzen den Entwicklungsbuild; das ist kein RMM-Serverstart. + Ein späterer Tag-/Architektur-/Bootwechsel verweigert vor Containerstart. + Der Builder erhält keine Host-Cargo-Konfiguration oder Credentials. Sein + vollständiges `CARGO_HOME=/cargo` liegt in einem eigenen begrenzten Tmpfs; + Cargo-/Rustup-Binaries bleiben im vertrauenswürdigen Image. Offline kann ein + lesender Registry-Symlink vorhandene Imagecaches benutzen; Cachelocks und + sonstige Cargo-Homedaten bleiben im eigenen beschreibbaren Home. +5. Erst nach separatem Review echter geschützter Chrony-Pins: + `host-probe --case --sha256 `. Ein demandgestarteter, + transienter Rootprozess läuft höchstens 3s unter eigener Unit; äußerer + Wächter 10s. Er darf nur AF_UNIX, keine IP-Verbindungen und schreibt lediglich + den eigenen temporären Chrony-Abfragesocket im festen Clientverzeichnis. + Keine Signatur oder Brokerinstanz entsteht. Keine Wiederholung einer + fehlgeschlagenen/unklaren Probe. +6. `host-read --case ` liest ausschließlich vorhandene begrenzte + Ergebnis-/Fehlerbelege und Intentpräsenz. Es startet keine Befehle oder + erneuten Proben. Vollständige Build-/Probeoriginale bleiben im privaten Fall. + +Eine unverifizierte Registrycache-Präsenz wird nie angenommen. Falls der erste +Offlinebuild wegen fehlender Dependencies scheitert, darf der Rootoperator in +einem **neuen** Fall ausdrücklich `host-build --registry-fetch` wählen. Dieser +Modus hat einen leeren begrenzten temporären vollständigen Cargo-Homemount und Netzwerkzugang +für den normalen Cargo-Registrydownload, weiterhin unveränderte Lockversionen +und geprüfte Checksums, keine OS-Updates. Das ist keine automatische +Fehlerwiederholung und auch kein eng auf bestimmte IPs beschränkter Egressfilter. + +## Lesender Preflight und Beweisgrenzen + +Der Host muss Root/Linux/aarch64 sein. Docker-Engineversion und vorhandenes +ARM64/Linux-Builderimage werden gelesen, kein Pull erfolgt. Für die festen +Composecontainer `rust-discovery-server-{gateway,api,postgres}-1` werden nur +Image-ID, Konto, Running/PID/Startzeit/RestartCount und Portbindungen gelesen. +API/Gateway müssen das bestehende Runtimeimage +`sha256:6f8383f7c762ac77ed1013c94eeafa2b76838c00aec358a375f5847645ea87ec` +und `10001:10001` verwenden. PostgreSQL darf keine publizierten Ports haben; +sonstige publizierte Dockerports müssen ausschließlich IPv4-Loopback sein. +Umgebungsvariablen, private Mountinhalte und Healthausgaben werden nicht gelesen. + +Chrony wird über den vorhandenen `chrony.service`-MainPID identifiziert. +PIDFD, Prozessgeburtszeit, reale/effective UID/GID, tatsächlicher Executableinode, +geschütztes `/usr/sbin/chronyd` samt SHA256 und Boot-ID werden beobachtet und +erneut verglichen. Dies ist eine begrenzte frische Beobachtung für spätere +Root-Pinprovisionierung, **keine** Sourcequalitätsabnahme. Der Provider prüft +später seine vollständigen gehaltenen Identitäten selbst. Das historische +Kernelresultat aus früheren Fällen ist kein frischer Qualitätsbeleg. + +Build und Probe vergleichen die genannten RMM-Containermetadaten und Boot-ID +vorher/nachher. Das belegt nur diese unveränderten Metadaten, keine vollständige +SQL-/PKI-/Dateninhaltsidentität oder auf Nanosekunden garantierte Schedulingzeit. +Aufbewahrte unveränderte Quellen sowie SHA256/Länge und ELF64/AArch64-Machine183 +beider Artefakte werden gesondert nachgewiesen. Ein lokaler x86-64-Build ersetzt +keinen ARM64-Lauf. Der Broker wird beim Build nicht gestartet. + +## Nächster Bootstrap-Schnitt: weiterhin nur ein Vorschlag + +Vor einer tatsächlichen Installation sind die nativen Linux-Brokerguards und +der Paket-/Artefaktreview abzuschließen. Folgende konkrete Änderungen gehören +in eine gesondert reviewte create-only Provisionierung; dieses Werkzeug führt +sie ausdrücklich noch nicht aus: + +- `/etc/rmm-time-source`: Root0700. `chrony-pin.json`: Root0600, ein Link, + strikt genau `schema_version`, `daemon_pid`, `daemon_birth_ticks`, + `daemon_uid`, `daemon_gid`, `daemon_image_sha256` aus derselben frischen + tatsächlichen Prozessbeobachtung. Boot-ID separat im Rootbeleg binden; kein + erfundenes zusätzliches Feld im strikt deserialisierten Providerpin. +- `signer.json`: Root0600, create-only; privater Ed25519-Zeitschlüssel aus + serverseitigem CSPRNG, niemals exportieren/loggen. Eigene Server-/Key-ID und + positive Generation. Tatsächlichen öffentlichen Jobkey über den vorhandenen + öffentlichen Getter und sämtliche bekannten Update-/Health-/TLS-Ed25519- + Rollen als dekodierte Verbotswerte aufnehmen; keine Dummywerte. Nur öffentlicher + Zeitpin/Hash darf zurückgegeben werden. Ein späterer Provisioner darf für den + öffentlichen Jobkey keine privaten PEM-Dateien lesen. +- `/run/rmm-time-source`: Root:10001 0710; `clients`: Root:frische-Chrony-GID + 0710. Geschützte Ancestry, keine automatische Übernahme fremder Objekte. + Boot-/Chronyneustart braucht erneute unabhängige Pinprüfung; kein stilles + Ersetzen oder Autostart mit veralteten Pins. +- `/usr/local/libexec/rmm-time-broker`: geprüfter ARM64-ELF-Hash, Root0500, + create-only. Keine Runtimeimageänderung, kein Compose-/RMM-Neustart. +- Demanddienst mit Rootkonto, primärer frischer Chrony-GID und ergänzender + Gruppe10001, `NoNewPrivileges=yes`, `CapabilityBoundingSet=CAP_SYS_PTRACE`, + keine `CAP_SYS_TIME`, AF_UNIX-only/IP-denied, `ProtectSystem=strict`, + `ProtectHome=yes`, `PrivateDevices=yes`, eigenem Runtime-Schreibverzeichnis + sowie `SystemCallFilter=~@debug ptrace process_vm_readv process_vm_writev`. + CAP_SYS_PTRACE dient ausschließlich dem gehaltenen `/proc//exe`- + Identitätszugriff bei anderer UID. Kein ptrace-/Speicherlesepfad entsteht. + `ProtectClock=yes` wird nicht blind gesetzt: dessen Seccompfilter kann auch + die ausschließlich lesende `adjtimex(modes=0)`-Probe sperren. + +Der Hostbroker erwartet echte UID/GID10001 und sichtbare Host-PID>1 des lokalen +Callers. Der Gatewaycontainer darf den Hostrootpeer dagegen namespacebedingt +als PID0 sehen; die bestehende Route verlangt dessen kernelbestätigte UID0, +geschützten festen Socketinode und unabhängige Zeitkeysignatur. Kein `pid:host`, +privilegierter Container oder Usernamespace-Mappingfallback. Dieses tatsächliche +Namespace-/UID-Profil bleibt vor späterem Gatewaydeploy nativ zu prüfen. + +Noch kein Zeitpin, signierter Zeitvergleich, Windows-Clockgate oder Jobfreigabe +wird allein durch einen erfolgreichen Provider-Sample aktiviert. Der Windows- +MVP ist mit diesem Teilschnitt weiterhin nicht abgeschlossen. + +## Tatsächlicher lokaler Nachweis, 2026-11-15 + +Der öffentliche Quellenabgleich und die netzlose Cargo-Lockgenerierung wurden +ausgeführt. Der generierte Lock enthält70 Pakete; alle Versionen/Quellen/ +Checksums stimmen mit dem öffentlichen Original überein. Ein anfänglicher +Versuch mit ausschließlich herausgeschnittenen Original-Lockblöcken wurde von +Cargo mit Exit101 wegen nötiger Graphnormalisierung verweigert; sein eigener +Fall `recipe-qualification-c69c3677-bf28-493d-855d-fdfa8ce12806` bleibt erhalten. +Er wurde durch die tatsächliche Offline-Lockgenerierung ersetzt. + +Der neue Fall `recipe-qualification-26b0527c-6b33-4229-8c09-b35563ed475e` baute +Broker und Probe mit `--locked --offline --release` erfolgreich, Exit0, lokal +auf x86-64. Broker1043088Bytes/SHA256 +`dc6f8946e38967aa8ab4c23a1bac83409eec5759dd0374dd0882f8ddb71dce99`, +Probe787128Bytes/SHA256 +`1b03957b8cc845086c9f88febd56bb2fd52270f10a75eae8f549bb1209bfcbb3`. +Die Compilerinputs sind bytegleich mit dem anschließend tatsächlich gegen den +öffentlichen Commit erzeugten Quellenpaket; Herkunftsbelege werden zusätzlich +mitgeführt und nicht kompiliert. + +Historischer privater Paketfall `80096c84-1187-4cc9-87c5-f54c9948b6b7`, Archiv225280Bytes, +SHA256 `aeee468480ece91caedc0e726be13de9d389eaf980221f4b1c8ecbaf1b01b35a`; +Historischer Operator-SHA256 +`0992a0ae4cf676634a2e515da9a3484101c7f4b938b2971252725ed3774688bc`. +ASTprüfung, vollständiger lokaler Archiv-/Hashroundtrip, Ablehnung eines +falschen Archivhashes, eines Archivsymlinks, einer geänderten Paketversion und +des x86-64-Artefakts als ARM64-Probe: PASS. Qualificationreceipt-SHA256 +`62f89e485ff3d2e503bae176ac6e22f86013cf677183a3a14d5498cecfb3b7bd`, +Capabilitymanifest-SHA256 +`4cbecde616df9bce8e5398fae909ba04d6b46c5cf62719b7b7bb237a1747f3fc`. +Die Originalreceipt dokumentiert die zu ihrem Prüfzeitpunkt vorhandene +Dokumentfassung; dieser nachträglich hinzugefügte Ergebnisabschnitt ändert +weder Operator, Paket noch Buildinputs. Keine SSH-/Serveraktion, ARM64-Ausführung, +Chronyprobe, Pin-/Signerprovisionierung oder Broker-/HTTP-Inbetriebnahme wurde +durch diesen lokalen Nachweis ausgeführt. + +## Reviewfix und tatsächlicher Deltanachweis, 2026-11-15 + +Ein unabhängiger Review fand vor irgendeiner Hostphase die erneute Auflösung +des Buildertags im Buildpfad. Der Pfad verlangt jetzt die unveränderte +Image-ID/Architektur/OS und Boot-ID aus dem ursprünglichen Preflight und baut +ausschließlich mit dieser gespeicherten Image-ID. Zusätzlich besitzt der +Container ein eigenes vollständiges Cargo-Home für Schreiblocks und Cachedateien; +der explizite Fetchmodus benötigt kein beschreibbares Imageroot. Keine Version +oder Zeitcrate wurde geändert. + +Build-/Probelogs werden während des Lesens auf8MiB begrenzt. Timeout/Überlauf +beendet ausschließlich die eigene noch nicht gereapte Prozessgruppe. Beim +Build wird zusätzlich der eigene Container anhand zurückbehaltener CID, +Originalimage, UUID-Name und UUID-Label geprüft, bevor genau diese CID beendet +werden darf. Kein globales oder allein namensbasiertes Docker-Kill. Bei fehlender +oder unklarer CID gibt es keinen Fallback; die unabhängige interne850s-Frist +bleibt erhalten und der Fall wird nicht wiederholt. Dies ist keine Garantie +für Reaktionszeiten bei blockiertem Kernel oder Dockerdaemon. + +Neuer privater Fall `d3be954b-518b-4232-bac4-5bf0a8f934cd`, Archiv225280Bytes, +SHA256 `25409193e431e19f04526998fcd28f5f75471995935c02f35e1fa9ba1a0eada9`, +Operator-SHA256 +`c97865ea83e35cc192aeb92c9c5684f2f33a937a01942ce3822c4305e3c3afd5`. +Der tatsächliche lokale x86-64-Offline-Releasebuild mit frischem vollständigem +Cargo-Home und lesendem Image-Registrycache bestand mit Exit0. Der lokale +Container nutzte für diesen Entwicklungsnachweis UID/GID1000; das geprüfte +Serverprofil bleibt Root. Keine ARM64-Ausführung wird daraus abgeleitet. + +Fünf gezielte Deltaprüfungen bestanden: Builderwechsel und Bootwechsel jeweils +vor Target-/Dockererzeugung verweigert, tatsächlicher9MiB-Ausgabestrom bei +exakt8MiB gestoppt samt Cancelhook, eigene Prozessdeadline samt Cancelhook und +ungültige CID vor Dockeraufruf verweigert. Die Image-/Bootprüfungen verwendeten +ausdrücklich lokale Fixtures; der Cancelhooktest belegt keinen tatsächlichen +Dockerdaemonabbruch auf dem Server. Deltabeleg-SHA256 +`54d0bc2372adafb0d222bb9a9f64b3120a8b59e40675467d58664adcb29f0889`. +Alter Paketfall und sämtliche Originalbelege bleiben unverändert. + +## Tatsächlicher erster Serverpreflight, 2026-11-15 + +Das öffentliche Operatorfile mit SHA256c97865ea wurde create-only in einem +eigenen Rootverzeichnis übertragen. Der erste Pythonaufruf scheiterte bereits +vor Moduleintritt: Der Dateiname `operator.py` überschattete das gleichnamige +Python-Standardmodul. Lesend bestätigt: derselbe `--help`-Aufruf scheitert ohne +Isolation, mit `python3 -I` gelingt er. Vor dem folgenden ersten tatsächlichen +Phaseneintritt war der native Fall nachweislich noch nicht vorhanden; es wurde +kein vorhandener Phasenintent wiederholt. Originaldiagnosereceipt-SHA256 +`928becb71d7db6f46d8a54e2ae9075d16eea4ee1cdbe82cbbf92d241ab39e15a`. +Hostaufrufe des archivierten Dateinamens müssen `python3 -I` verwenden. + +Der anschließende erste native Preflight im Originalfall d3be954b scheiterte +kontrolliert, ohne Stage/Build/Probe. Phasenreceipt-SHA256 +`e4b4909871dea35ed41a9a1df527fea0a262218d0a60030352ecc00b3ac73944`, +separater Originalfall-Readback +`c3d2cc60d9a65320b2874795f97ffba23be9699c67d2cebb6e8c46e36bb90cf2`. +Eine zusätzliche lesende Diagnose lokalisiert die nicht erfüllte Annahme: +Der MainPID von chrony.service gehört einem Shellwrapper, nicht dem tatsächlichen +chronyd-Executable. Die geschützte feste Datei ist vorhanden, der Dienstcgroup +enthält außerdem zwei echte chronyd-Prozesse. Eine blinde Auswahl nach Name +oder niedrigster PID wäre deshalb falsch. Herkunft und tatsächliche +Daemonrolle müssen im folgenden Quellenfix exakt gebunden werden. +Readonly-Cgroupreceipt-SHA256 +`c07d6e0c9a2d86cb042c8b83402aa548bf34294dddffd3f91a036280510b05fd`. + +Der vorhandene Builder ist tatsächlich ARM64/Linux, immutable Image-ID +`sha256:e6f2cff35d0f309acf8433b4f05878ed77092602c5065cc81801177da0bb3a9c`. +Dieser Metadatenbefund ersetzt keinen erfolgreichen vollständigen Preflight +oder ARM64-Build. Kein Chrony-/RMM-Neustart, kein Zeitsetter, Pin, Schlüssel, +Broker oder Serverdeploy wurde vorgenommen. Der fehlgeschlagene Fall bleibt +erhalten und wird nicht erneut ausgeführt. diff --git a/docs/windows-signed-clock-capture-operator.md b/docs/windows-signed-clock-capture-operator.md new file mode 100644 index 0000000..6724ff7 --- /dev/null +++ b/docs/windows-signed-clock-capture-operator.md @@ -0,0 +1,159 @@ +# Separater Operator für die Windows-Rohclockprobe + +Stand2026-11-15, Spezifikation1.22. Neuer Quellpfad: +`deploy/windows/signed_clock_capture_acceptance.py`. Dieser Runner ist ein +enger Entwicklungsbootstrap für genau zwei eigene temporäre SCM-Fixtures. +Kein RMM-Job, keine Calibration, kein Zeitpin, kein TrustedClock-/Readybeleg. +Die [Probequelle](windows-signed-clock-capture.md) bleibt unverändert. + +Der ursprüngliche Quellenauftrag führte keine Zielaktion aus. Die späteren +tatsächlichen Operatorphasen und ihre Fehler sind im Ergebnisabschnitt unten +getrennt dokumentiert; geplante Befehle sind kein Erfolgsnachweis. + +## Vorbedingungen und feste Herkunft + +Nur der Rootoperator führt den Runner nach unabhängigem Review aus. Sein +`CaptureAccess` verwendet unverändert `system_pipe_upgrade.Access(MainRoot)` +für den bereits gepinnten SSH- und Serverzugang. Credentials bleiben ausschließlich +im Maincheckout und werden erst durch die tatsächliche Operatorphase gelesen. +Keine Kopie, kein alternativer Host, kein Hostkeybypass und keine Shellauswertung +von Konfigurationsdaten. Zwei neue feste Stagenamen sind ausschließlich +`SignedClockCapture.exe` und `SignedClockCaptureAcceptance.ps1`; alte Allowlisten +werden nicht erweitert oder verändert. + +Vor der lokalen Vorbereitung werden190 gefrorene Inputs, Receiptba9ba8d8, +Inputmanifest2d21da4d und Readonlymanifest91c75ba8 geprüft. Windowsprobe: +8566784Bytes, SHA256 +`601c27a43fb67c662f926f9dc289a23a5c31c7e27f62901a77fc9ceaafaea7fb`. +Die neue vorbereitete Fallkopie verwendet700/600, exklusive Dateien und fsync. +Ein fester lokaler Active-Intent verhindert einen neuen Fall als Ersatz für +einen unklaren Versuch. Es gibt keinen Reset- oder automatischen Retrypfad. + +Pflicht ist der tatsächliche Linux-first-Nachweis des exakt selben Rawquellsatzes: +Originalfall `dcef489d-2a24-47cc-b3ca-6628545cdacf`, Originalread +`read-80f83bff-183b-4697-80b2-9b96a8182e8d.json`, SHA256 +`91a750e4de266f5effccbd418a680c1ba4f5e0aff5082489fc021922bdfcafa3`. +5Guards bestanden,10 ausdrücklich gefiltert,15vorher gelistet; Originalmanifest, +Receipt und unveränderte Before-/After-/Currentwitnesses müssen passen. +Dieser Pflichtbeleg ist kein tatsächlicher Windows-Timernachweis. + +Der angenommene reale Windowsbestand bleibt ausschließlich der akzeptierte +14fb176a-Fall samt originalen Mainindices. Der Runner ruft dessen bestehenden +`finish` ausschließlich lesend auf. Er akzeptiert keine andere Boot-/PID-/ +SCM-Generation und repariert keine Indices oder Identität automatisch. + +## Geplante Phasen, nicht ausgeführt + +Auf dem Entwicklungsrechner, im Clockworktree: + +```text +python3 deploy/windows/signed_clock_capture_acceptance.py prepare +python3 deploy/windows/signed_clock_capture_acceptance.py baseline --case +python3 deploy/windows/signed_clock_capture_acceptance.py setup --case +python3 deploy/windows/signed_clock_capture_acceptance.py start-local-service --case +python3 deploy/windows/signed_clock_capture_acceptance.py start-system --case +python3 deploy/windows/signed_clock_capture_acceptance.py read --case +python3 deploy/windows/signed_clock_capture_acceptance.py cleanup-local-service --case +python3 deploy/windows/signed_clock_capture_acceptance.py cleanup-system --case +python3 deploy/windows/signed_clock_capture_acceptance.py read --case +``` + +`prepare` ist rein lokal. `baseline` liest tatsächliche Serverflags/Zähler und +den unveränderten nativen Windowsbestand. Vor und nach **jeder** mutierenden +Phase werden exakt sechs vollständige stabile Felder verglichen: `files`, +`service`, `helper_service`, `agent_kernel`, `helper_kernel`, `helper_witness`. +`public_metadata` wird nicht ausgeklammert. Zusätzlich bleiben Journaldatei-ID, +Creation, IdentitySHA, Schema und Corecounts gleich; die passive Telemetrie- +sequenz darf nur steigen. Pending-/ACK-Telemetrie wird nicht bytegleich verlangt. +Windows0/0/0/0, Linux31/31/27/0, geschlossene Rootpolicycf15 und deaktivierte +Transportfaults müssen tatsächlich unverändert sein. Historische30er-Zähler +werden nicht übernommen. Unerwartete neue Generation bedeutet Stop und Befund. + +`setup` erzeugt nur seinen neuen eigenen Fall unter +`C:\ProgramData\RustDiscoverySignedClockCapture\`, einen privaten +Controllerbereich und genau die beiden festen Demand-Start-/OWN_PROCESS- +Dienste `RmmSignedClockCaptureLocalService` und `RmmSignedClockCaptureSystem`. +Konten sind LocalService/SID19 und LocalSystem/SID18. Beide eigene Dienst-SIDs +werden eingeschaltet, beide Definitionen entstehen vor dem ersten Rollenstart. +Root/System verwalten Definitionen und Case; Lesen erhalten nur beide eigenen +Fixture-SIDs, Schreiben nur die jeweils eigene SID im eigenen Rollenunterordner. +Keine allgemeine SID19-/Users-Schreibfreigabe. Die EXE wird ausschließlich aus +dem vollständig verifizierten unveränderlichen Staging kopiert. + +Jede Startphase schreibt ihren dauerhaften Attempt vor dem einmaligen SCM- +Start. Der Operator hält tatsächlichen Prozesshandle, PID, native Geburt, +Imagepfad, Account und aktivierte Dienst-SID. Der feste Commandlinevektor muss +zusätzlich passen. Es gibt keinen PID-basierten globalen Kill. Der Watchdog +beobachtet eigene GetTickCount64-Uptime: nach40s nur den weiterhin exakt +gebundenen eigenen Prozesshandle terminieren, anschließend höchstens5s auf +Kernelprozessende warten. Ohne gehaltene exakte Identität bleibt Timeout unklar; +kein Fremdprozess wird übernommen. Der SSH-Controllertransport hat einen +separaten90s-Abbruch. Synchrone Kernel-/SCM-/CIM-Aufrufe und Schedulerstillstand +sind keine harte Echtzeitgarantie. Die feste Boot-CIM-Probe kann vor der +250ms-Rawerhebung bis15s benötigen. Managed Compiler-/Runtime-Temporärarbeit +des festen Add-Type-Interop folgt dem vorhandenen Bootstrapmuster und erteilt +keine RMM- oder beliebige Programmausführung. + +Erfolg verlangt durable Probe-Intent/Report/End, numerische128er-Serie, +ImageSHA601c27, passende Rollen-/Token-/Geburtsbindung und tatsächlich beobachtetes +Kernelprozessende plus SCM-Stopped/Exit0. Ein Timeout oder fehlender Endbeleg +wird nicht durch späteren Zustand geheilt. `calibrated=false` und +`clock_authority=false` bleiben unverändert. Die Antwort enthält nur feste +Rollen, Fall-ID und begrenzte numeric/hash-Diagnosedaten; CLI meldet nur eine +kleine ASCII-JSON-Zusammenfassung. + +Cleanup ist ein eigener expliziter Schritt. Nur dieselbe exakt konfigurierte, +bereits gestoppte eigene Definition darf einmal gelöscht werden. Für einen +begonnenen Start ist der erhaltene native Exitbeleg Pflicht; eine nie gestartete +Definition wird dadurch nicht nachträglich gestartet. Dauerhafter Delete-Attempt +vor DeleteService, danach echte Abwesenheitsprüfung. Sobald Cleanup beginnt, +bleiben weitere Starts geschlossen. Fallverzeichnisse und Rohbelege bleiben +zur Prüfung liegen; keine rekursive Bereinigung. + +Nach verlorenem Reply ausschließlich `read` desselben Originals. Das startet +weder Probe noch Dienste und löscht nichts. Partielle Setupzustände werden +als unvollständig und unverifiziert sichtbar, nicht als Abnahme ausgegeben. +Auch ein erfolgreich beendeter Rohsampler beweist nur beobachtete Timerwerte +unter OS-/Hypervisorannahmen, keine absolute physikalische Genauigkeit und +keinen zulässigen Grundfehler für einen produktiven Clockpin. + +RMM-Dienste, PKI, Datenbanken, Helperpins, Rootpolicy, W32Time und Clocksetter +werden von diesem Controller nicht verändert. Dauerhafte Jobs benötigen +weiterhin ihren unveränderlichen WebUI-genehmigten Plan. Die native Windows- +Ausführung, Grundfehlerbewertung, echte unabhängige Agent-/SYSTEM-Roundtrips +und Runtime-/Deadlineintegration bleiben getrennte Gates. + +## Tatsächliche native Schritte, 2026-11-15 + +Originalfall `efd17b43-7e04-49a7-9bd4-862d13365eec`, Operator-SHA256 +`dd6c575a119751429448e40e6f306cf79efa3a86c49bf2cd32a7783937177770`, +Controller-SHA256 +`89c19138e2804f263f1875c7697a7d53f54f40722101677b4d29538c917196f4`. +Lokale Vorbereitung und lesende native Baseline bestanden. Auf der Windows-VM +bestand PowerShell5.1.26100.9818 die ASTprüfung ohne Fehler und kompilierte +den extrahierten C#-Interop; der Controller wurde dabei nicht ausgeführt. +Syntaxreceipt-SHA256 +`cec5ad635814fba9a6e98932b6df5b5204178b3e39e3c2361ccec211b5676b5a`. + +Die anschließende einmalige Einrichtung scheiterte mit Win32Exception auf +Controllerzeile138. Keine Rollenstartphase wurde aufgerufen. Separater +Originalfall-Readback `3890b0a6-2691-4f6b-8968-c268e031dff9` ist vollständig, +Receipt-SHA256 +`bc2a4be1b27ef02f6111e7ed82e58efab7df40af84e9253c77836675282f70ae`. +Er meldet ausdrücklich `partial_setup=true`: eigener LocalService-Messdienst +vorhanden und gestoppt, eigener SYSTEM-Messdienst fehlt. Die sechs vollständigen +RMM-Witnesses und Serverzähler wurden unverändert nachgelesen. Das ist kein +erfolgreicher Setup-, Capture-, Calibration- oder Uhrbereitschaftsnachweis. + +Eine zusätzliche rein lesende SCM-Abfrage bestätigt LocalService-Konto, +Demandstart, feste Originalkommandozeile, UNRESTRICTED-Dienst-SID und +SYSTEM/Administrators-DACL. Receipt-SHA256 +`ff8e2eef73139c8350aa0f86c6fed5125fce95f79d535f25224829ce4fa9c565` +bindet die separaten Originalmarker: LocalService-created vorhanden, +SYSTEM-create-attempt vorhanden, SYSTEM-created fehlt. Damit scheiterte +die zweite Erstellung; die ursprüngliche innere native Fehlernummer wurde +vom bestehenden Transport nicht erhalten. Ein PowerShell-null/String-Binding +ist ein konkreter Quellenverdacht, noch kein gemessener NativeErrorCode. +Kein Setupretry, neuer Ersatzfall, Dienststart oder Cleanup wurde vorgenommen. +Die gestoppte eigene Fixture bleibt bis zu gesondert geprüfter Reparatur oder +Bereinigung sichtbar erhalten. RMM-Dienste und W32Time bleiben unverändert.