Record real clock bootstrap failures and preserve isolated operators
Rust development slice / linux (push) Failing after 6s
Rust development slice / linux (push) Failing after 6s
This commit is contained in:
@@ -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('<H', raw[18:20])[0] == 183,
|
||||
'actual ELF64 little-endian AArch64 artifact')
|
||||
return {'bytes': len(raw), 'sha256': digest(raw), 'elf_machine': 183}
|
||||
|
||||
|
||||
def build(case, phase, fetch):
|
||||
staged = verify_workspace(case)
|
||||
original = json.loads(regular(case / 'preflight/result.json'))
|
||||
before = preflight()
|
||||
require(before['builder'] == original['builder'] and before['boot_id'] == original['boot_id'] and
|
||||
original['builder']['Architecture'] == 'arm64' and original['builder']['Os'] == 'linux' and
|
||||
re.fullmatch('sha256:[0-9a-f]{64}', original['builder']['Id']),
|
||||
'original preflight immutable builder and boot; no silent tag reimage')
|
||||
image_id = original['builder']['Id']
|
||||
target = phase / 'target'
|
||||
target.mkdir(mode=0o700)
|
||||
cidfile = phase / 'container.id'
|
||||
# All Cargo lock/cache writes belong to this fresh bounded home. Offline
|
||||
# may read the cached image registry; explicit fetch gets an empty registry.
|
||||
setup = 'set -eu; '
|
||||
if not fetch:
|
||||
setup += 'if test -d /usr/local/cargo/registry; then ln -s /usr/local/cargo/registry /cargo/registry; fi; '
|
||||
setup += 'exec cargo "$@"'
|
||||
args = ['docker', 'run', '--rm', '--pull=never', '--network', 'bridge' if fetch else 'none',
|
||||
'--read-only', '--cap-drop=ALL', '--security-opt=no-new-privileges', '--pids-limit=256',
|
||||
'--memory=2g', '--cpus=2', '--tmpfs=/tmp:rw,nosuid,nodev,size=256m',
|
||||
'--tmpfs=/cargo:rw,nosuid,nodev,size=512m,mode=0700', '-e', 'CARGO_HOME=/cargo',
|
||||
'-v', str(case / 'workspace') + ':/src:ro', '-v', str(target) + ':/out:rw',
|
||||
'--name=rmm-time-source-build-' + case.name,
|
||||
'--cidfile=' + str(cidfile),
|
||||
'--label=rmm.time-source.case=' + case.name,
|
||||
'-e', 'CARGO_TARGET_DIR=/out', '--entrypoint=/usr/bin/timeout', image_id,
|
||||
'--kill-after=3s', '850s', '/bin/sh', '-c', setup, 'rmm-fixed-cargo',
|
||||
'build', '--manifest-path', '/src/Cargo.toml', '--locked', '--release',
|
||||
'-p', 'rmm-time-broker-linux', '-p', 'rmm-time-source-linux', '--bins', '--examples']
|
||||
if not fetch:
|
||||
args.append('--offline')
|
||||
code = long_command(args, phase / 'build.log', 900,
|
||||
cancel=lambda: cancel_owned_builder(cidfile, image_id, case.name))
|
||||
after = preflight()
|
||||
require(before['runtime'] == after['runtime'] and before['boot_id'] == after['boot_id'],
|
||||
'RMM runtime metadata and boot preserved')
|
||||
verify_workspace(case)
|
||||
result = {'exit_code': code, 'registry_fetch_explicit': fetch, 'builder': before['builder'],
|
||||
'before': before, 'after': after, 'staged_manifest_sha256': staged['manifest_sha256'],
|
||||
'build_log_sha256': digest(regular(phase / 'build.log', 8 * 1024 * 1024)),
|
||||
'runtime_metadata_equal': True, 'native_source_quality_tested': False}
|
||||
if code == 0:
|
||||
# Cargo may hardlink release outputs to deps/. Copy exact immutable bytes
|
||||
# into fresh single-link root-owned artifacts before any probe execution.
|
||||
artifacts = phase / 'artifacts'
|
||||
artifacts.mkdir(mode=0o700)
|
||||
result['artifacts'] = {}
|
||||
for name in ('rmm-time-broker-linux', 'examples/operator_probe'):
|
||||
raw = regular(target / 'release' / name, 32 * 1024 * 1024, single_link=False)
|
||||
artifact = artifacts / Path(name).name
|
||||
exclusive(artifact, raw, mode=0o500)
|
||||
result['artifacts'][name] = elf(artifact)
|
||||
else:
|
||||
result['blocked'] = 'BUILD_FAILED_READ_LOG; offline cache is not assumed; no automatic retry/fetch'
|
||||
return result
|
||||
|
||||
|
||||
def probe(case, phase, expected):
|
||||
require(re.fullmatch('[0-9a-f]{64}', expected) is not None, 'operator-approved exact probe SHA')
|
||||
built = json.loads(regular(case / 'build' / 'result.json'))
|
||||
path = case / 'build/artifacts/operator_probe'
|
||||
artifact = elf(path)
|
||||
require(built['exit_code'] == 0 and artifact == built['artifacts']['examples/operator_probe']
|
||||
and artifact['sha256'] == expected, 'qualified original ARM64 source-only artifact')
|
||||
verify_workspace(case)
|
||||
# A previous provisioning action is a separate reviewed operation. Never synthesize pins here.
|
||||
protected_dir(Path('/etc/rmm-time-source'))
|
||||
pin = Path('/etc/rmm-time-source/chrony-pin.json')
|
||||
meta = metadata(pin)
|
||||
require(stat.S_ISREG(meta['mode']) and meta['uid'] == 0 and stat.S_IMODE(meta['mode']) == 0o600,
|
||||
'real protected Chrony pin required')
|
||||
protected_dir(Path('/run/rmm-time-source/clients'))
|
||||
before = preflight()
|
||||
args = ['systemd-run', '--quiet', '--wait', '--pipe', '--collect',
|
||||
'--unit=rmm-time-source-probe-' + case.name, '--property=Type=exec',
|
||||
'--property=User=root', '--property=Group=' + str(before['chrony_observation']['daemon_gid']),
|
||||
'--property=SupplementaryGroups=10001', '--property=NoNewPrivileges=yes',
|
||||
'--property=CapabilityBoundingSet=CAP_SYS_PTRACE', '--property=AmbientCapabilities=',
|
||||
'--property=ProtectSystem=strict', '--property=ProtectHome=yes',
|
||||
'--property=PrivateTmp=yes', '--property=PrivateDevices=yes',
|
||||
'--property=RestrictAddressFamilies=AF_UNIX', '--property=IPAddressDeny=any',
|
||||
'--property=SystemCallFilter=~@debug ptrace process_vm_readv process_vm_writev',
|
||||
'--property=RuntimeMaxSec=3s', '--property=ReadWritePaths=/run/rmm-time-source/clients', str(path)]
|
||||
code = long_command(args, phase / 'probe.log', 10)
|
||||
after = preflight()
|
||||
require(before['runtime'] == after['runtime'] and before['boot_id'] == after['boot_id'],
|
||||
'RMM runtime metadata and boot preserved')
|
||||
raw = regular(phase / 'probe.log', 16384)
|
||||
sample = None
|
||||
if code == 0:
|
||||
sample = json.loads(raw)
|
||||
require(sample['profile'] == 'rmm.native-source-quality.once.v1' and
|
||||
sample['clock_authority'] is False and sample['signed_attestation'] is False,
|
||||
'source-only single sample, no clock authority')
|
||||
return {'exit_code': code, 'artifact': artifact, 'before': before, 'after': after,
|
||||
'sample': sample, 'probe_log_sha256': digest(raw), 'runtime_metadata_equal': True,
|
||||
'signer_provisioned': False, 'broker_started': False, 'http_deployed': False}
|
||||
|
||||
|
||||
def host(args):
|
||||
case = host_case(args.case, create=args.command == 'host-preflight')
|
||||
if args.command == 'host-read':
|
||||
# No phase creation, Docker actions, signals or rerun. Read only original bounded case records.
|
||||
print(json.dumps({name: {'result': json.loads(regular(case / name / 'result.json'))
|
||||
if (case / name / 'result.json').exists() else None,
|
||||
'failure': json.loads(regular(case / name / 'failure.json'))
|
||||
if (case / name / 'failure.json').exists() else None,
|
||||
'intent_present': (case / name / 'intent.json').exists()}
|
||||
for name in ('preflight', 'stage', 'build', 'probe')}, sort_keys=True))
|
||||
return
|
||||
name = args.command.removeprefix('host-')
|
||||
phase = case / name
|
||||
phase.mkdir(mode=0o700) # An existing intent OR result never permits rerun.
|
||||
exclusive(phase / 'intent.json', encoded({'profile': PROFILE, 'case': case.name, 'phase': name,
|
||||
'operator_sha256': digest(Path(__file__).read_bytes()), 'started_unix_ns': time.time_ns()}))
|
||||
try:
|
||||
if name == 'preflight':
|
||||
result = preflight()
|
||||
elif name == 'stage':
|
||||
result = unpack(case, args.sha256)
|
||||
elif name == 'build':
|
||||
result = build(case, phase, args.registry_fetch)
|
||||
else:
|
||||
result = probe(case, phase, args.sha256)
|
||||
exclusive(phase / 'result.json', encoded(result))
|
||||
print(json.dumps({'case': case.name, 'phase': name, 'result': result}, sort_keys=True))
|
||||
except Exception as error:
|
||||
# Fixed controlled messages only; never write exception repr, paths from secrets, nested errors or env.
|
||||
exclusive(phase / 'failure.json', encoded({'failed': True, 'exception_type': type(error).__name__,
|
||||
'read_original_case_only': True}))
|
||||
raise
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
commands = parser.add_subparsers(dest='command', required=True)
|
||||
prepare_parser = commands.add_parser('prepare')
|
||||
prepare_parser.add_argument('--commit', required=True)
|
||||
for name in ('preflight', 'stage', 'build', 'probe', 'read'):
|
||||
command = commands.add_parser('host-' + name)
|
||||
command.add_argument('--case', required=True)
|
||||
if name in ('stage', 'probe'):
|
||||
command.add_argument('--sha256', required=True)
|
||||
if name == 'build':
|
||||
command.add_argument('--registry-fetch', action='store_true',
|
||||
help='explicit operator-authorized crates.io fetch using locked checksums; never OS updates')
|
||||
args = parser.parse_args()
|
||||
if args.command == 'prepare':
|
||||
prepare(args.commit)
|
||||
else:
|
||||
host(args)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@@ -0,0 +1,510 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Fixed two-role raw Windows clock bootstrap; never an RMM job or calibration.
|
||||
|
||||
prepare is local only. Every mutation is create-once. After a lost reply use
|
||||
read on the original case; cleanup is separately explicit and stopped-only.
|
||||
"""
|
||||
import argparse
|
||||
import base64
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import stat
|
||||
import subprocess
|
||||
import uuid
|
||||
|
||||
import system_pipe_upgrade as pipe
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
ACCESS_ROOT = ROOT.parent / 'rust-discovery'
|
||||
STATE = ROOT / 'devstate/windows-signed-clock-capture-native'
|
||||
QUALIFICATION = ROOT / 'devstate/windows-signed-clock/raw-capture-qualification-6bcd72a7-6de7-48e6-9e9b-3ad2cd3d9b09'
|
||||
RECEIPT_SHA = 'ba9ba8d88ed71952dd8dc803f2e38d5da72edeae392818cd320c6fd532ac7f4d'
|
||||
INPUTS_SHA = '2d21da4d137d2efd48cb2679fb791a9055839b042373d0f38c5af8d9ea8c5a8c'
|
||||
CAP_SHA = '91c75ba877764345b3267731f3880580d02a72df40420479e3c4b76d37064982'
|
||||
EXE_SHA = '601c27a43fb67c662f926f9dc289a23a5c31c7e27f62901a77fc9ceaafaea7fb'
|
||||
EXE_BYTES = 8566784
|
||||
NATIVE_CASE = ROOT / 'devstate/windows-raw-clock-native-linux/dcef489d-2a24-47cc-b3ca-6628545cdacf'
|
||||
LINUX_READ = NATIVE_CASE / 'read-80f83bff-183b-4697-80b2-9b96a8182e8d.json'
|
||||
LINUX_READ_SHA = '91a750e4de266f5effccbd418a680c1ba4f5e0aff5082489fc021922bdfcafa3'
|
||||
MAIN_CASE = ACCESS_ROOT / 'devstate/windows-client/system-pipe-upgrade/14fb176a-f653-4573-a8d7-6f9fe47a3020'
|
||||
MAIN_INTENT_SHA = '374adc97bec41bd798409f7c4f8c7716b085e20d2b6fb64b33f7ab675e6483e2'
|
||||
MAIN_RESULT_SHA = 'd5c4996821911a5bdac5014e9f985c56bbb592b803f2e33411dd28bb986b8eed'
|
||||
INDEX_SHAS = {'current-runtime.json': 'e49231e72aff7b001189b8507200c6c701f73e47f77c29194116cf1da41ca0c2',
|
||||
'current-components.json': '005317e652f50de3e1277be3bc42717318226208015e7c8011e1b73469cc7562'}
|
||||
ROOT_POLICY = 'cf15cbb68b590475df6def28e7dcffb7d88e0ca2d2555a06174fb654eeff05f4'
|
||||
PROFILE = 'rmm.windows.raw-clock.two-role-bootstrap.v1'
|
||||
STABLE = ('files', 'service', 'helper_service', 'agent_kernel', 'helper_kernel', 'helper_witness')
|
||||
JOURNAL = ('database_file_id', 'database_creation', 'identity_sha256', 'schema', 'core_counts')
|
||||
require = pipe.require
|
||||
|
||||
|
||||
def sha(path):
|
||||
return hashlib.sha256(Path(path).read_bytes()).hexdigest()
|
||||
|
||||
|
||||
def canonical(value):
|
||||
return json.dumps(value, ensure_ascii=True, separators=(',', ':'), sort_keys=True).encode()
|
||||
|
||||
|
||||
def private(path, directory=False):
|
||||
metadata = Path(path).lstat()
|
||||
require(metadata.st_uid == os.getuid() and stat.S_IMODE(metadata.st_mode) == (0o700 if directory else 0o600)
|
||||
and (stat.S_ISDIR(metadata.st_mode) if directory else stat.S_ISREG(metadata.st_mode) and metadata.st_nlink == 1), 'private own case')
|
||||
|
||||
|
||||
def load(path):
|
||||
private(path)
|
||||
require(Path(path).stat().st_size <= 2 * 1024 * 1024, 'bounded private evidence')
|
||||
return json.loads(Path(path).read_bytes(), object_pairs_hook=pipe.cb.contract.strict_object)
|
||||
|
||||
|
||||
def write(path, raw):
|
||||
private(path.parent, True)
|
||||
fd = os.open(path, 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(path.parent, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW)
|
||||
try:
|
||||
os.fsync(fd)
|
||||
finally:
|
||||
os.close(fd)
|
||||
|
||||
|
||||
def save(path, value):
|
||||
write(path, canonical(value))
|
||||
|
||||
|
||||
# Exact previously reviewed kernel-handle/account/image proof only. No original
|
||||
# replacement, stop/start, state or recovery functions are imported into SCRIPT.
|
||||
NATIVE_BASE = pipe.NATIVE.split("'@\nfunction FileIdentity", 1)[0]
|
||||
NATIVE = NATIVE_BASE + r'''
|
||||
public static class RmmCaptureControl {
|
||||
[DllImport("advapi32.dll",SetLastError=true,CharSet=CharSet.Unicode)] static extern IntPtr OpenSCManager(string machine,string database,uint access);
|
||||
[DllImport("advapi32.dll",SetLastError=true,CharSet=CharSet.Unicode)] static extern IntPtr CreateService(IntPtr manager,string name,string display,uint access,uint type,uint start,uint error,string command,string group,IntPtr tag,string dependencies,string account,string password);
|
||||
[DllImport("advapi32.dll",SetLastError=true,CharSet=CharSet.Unicode)] static extern IntPtr OpenService(IntPtr manager,string name,uint access);
|
||||
[DllImport("advapi32.dll",SetLastError=true)] static extern bool CloseServiceHandle(IntPtr handle);
|
||||
[DllImport("advapi32.dll",SetLastError=true)] static extern bool ChangeServiceConfig2(IntPtr handle,uint level,ref uint value);
|
||||
[DllImport("advapi32.dll",SetLastError=true)] static extern bool StartService(IntPtr handle,uint count,IntPtr args);
|
||||
[DllImport("advapi32.dll",SetLastError=true)] static extern bool DeleteService(IntPtr handle);
|
||||
[DllImport("advapi32.dll",SetLastError=true)] static extern bool QueryServiceStatusEx(IntPtr handle,int level,out Status value,int size,out int needed);
|
||||
[DllImport("advapi32.dll",SetLastError=true)] static extern bool SetServiceObjectSecurity(IntPtr handle,uint info,IntPtr descriptor);
|
||||
[DllImport("advapi32.dll",SetLastError=true,CharSet=CharSet.Unicode)] static extern bool ConvertStringSecurityDescriptorToSecurityDescriptor(string text,uint revision,out IntPtr descriptor,out uint size);
|
||||
[DllImport("kernel32.dll")] static extern IntPtr LocalFree(IntPtr value);
|
||||
[DllImport("kernel32.dll",SetLastError=true)] static extern IntPtr OpenProcess(uint access,bool inherit,int pid);
|
||||
[DllImport("kernel32.dll",SetLastError=true)] static extern bool TerminateProcess(RmmPipeNative.Held handle,uint code);
|
||||
[DllImport("kernel32.dll",SetLastError=true)] static extern bool GetExitCodeProcess(RmmPipeNative.Held handle,out uint code);
|
||||
[DllImport("kernel32.dll")] public static extern ulong GetTickCount64();
|
||||
[StructLayout(LayoutKind.Sequential)] public struct Status {public uint Type,State,Controls,Win32Exit,SpecificExit,Checkpoint,WaitHint,Pid,Flags;}
|
||||
public sealed class Service : SafeHandleZeroOrMinusOneIsInvalid {
|
||||
public Service(IntPtr value):base(true){SetHandle(value);}
|
||||
protected override bool ReleaseHandle(){return CloseServiceHandle(handle);}
|
||||
public Status Read(){Status s;int bytes;if(!QueryServiceStatusEx(handle,0,out s,Marshal.SizeOf(typeof(Status)),out bytes)||bytes!=Marshal.SizeOf(typeof(Status)))throw new Win32Exception();return s;}
|
||||
public void StartOnce(){if(!StartService(handle,0,IntPtr.Zero))throw new Win32Exception();}
|
||||
public void DeleteOnce(){if(!DeleteService(handle))throw new Win32Exception();}
|
||||
}
|
||||
static IntPtr Manager(uint access){IntPtr value=OpenSCManager(null,null,access);if(value==IntPtr.Zero)throw new Win32Exception();return value;}
|
||||
public static Service CreateOnce(string name,string command,string account){
|
||||
IntPtr manager=Manager(3);try{IntPtr value=CreateService(manager,name,name,0xf01ff,16,3,1,command,null,IntPtr.Zero,null,account,null);if(value==IntPtr.Zero)throw new Win32Exception();
|
||||
Service service=new Service(value);try{uint sid=1;if(!ChangeServiceConfig2(value,5,ref sid))throw new Win32Exception();IntPtr sd;uint size;if(!ConvertStringSecurityDescriptorToSecurityDescriptor("D:P(A;;GA;;;SY)(A;;GA;;;BA)",1,out sd,out size))throw new Win32Exception();try{if(!SetServiceObjectSecurity(value,4,sd))throw new Win32Exception();}finally{LocalFree(sd);}return service;}catch{service.Dispose();throw;}
|
||||
}finally{CloseServiceHandle(manager);}
|
||||
}
|
||||
public static Service OpenOwn(string name){IntPtr manager=Manager(1);try{IntPtr value=OpenService(manager,name,0x10015);if(value==IntPtr.Zero)throw new Win32Exception();return new Service(value);}finally{CloseServiceHandle(manager);}}
|
||||
public static RmmPipeNative.Held Hold(int pid){IntPtr value=OpenProcess(0x101001,false,pid);if(value==IntPtr.Zero)throw new Win32Exception();return new RmmPipeNative.Held(value);}
|
||||
public static void KillHeld(RmmPipeNative.Held process){if(!TerminateProcess(process,1460))throw new Win32Exception();}
|
||||
public static uint Exit(RmmPipeNative.Held process){uint code;if(!GetExitCodeProcess(process,out code))throw new Win32Exception();return code;}
|
||||
}
|
||||
'@
|
||||
'''
|
||||
|
||||
SCRIPT = r'''
|
||||
$ErrorActionPreference='Stop';$p=$global:RmmSignedClockCapturePayload
|
||||
if(!$p-or[guid]::ParseExact($p.id,'D').ToString()-cne$p.id-or$p.id-notmatch'^[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$'-or$p.profile-cne'rmm.windows.raw-clock.two-role-bootstrap.v1'-or$p.action-notin@('setup','start-local-service','start-system','read','cleanup-local-service','cleanup-system')-or$p.exe_sha256-cne'601c27a43fb67c662f926f9dc289a23a5c31c7e27f62901a77fc9ceaafaea7fb'-or$p.exe_bytes-ne8566784-or$p.script_sha256-notmatch'^[a-f0-9]{64}$'-or$p.manifest_sha256-notmatch'^[a-f0-9]{64}$'){throw 'Fixed capture request'}
|
||||
if((($p.PSObject.Properties.Name|Sort-Object)-join',')-cne'action,exe_bytes,exe_sha256,id,manifest_sha256,profile,script_sha256'){throw 'Exact capture payload fields'}
|
||||
$base='C:\ProgramData\RustDiscoverySignedClockCapture';$case=Join-Path $base $p.id;$control=Join-Path $case 'control';$exe=Join-Path $case 'SignedClockCapture.exe';$boot='C:\ProgramData\RustDiscoveryBootstrap'
|
||||
$names=@('RmmSignedClockCaptureLocalService','RmmSignedClockCaptureSystem');$tags=@('local-service','system');$owners=@('S-1-5-19','S-1-5-18');$accounts=@('NT AUTHORITY\LocalService','LocalSystem');$sys='S-1-5-18';$admin='S-1-5-32-544'
|
||||
function HashBytes([byte[]]$raw){$h=[Security.Cryptography.SHA256]::Create();try{return([BitConverter]::ToString($h.ComputeHash($raw))).Replace('-','').ToLowerInvariant()}finally{$h.Dispose()}}
|
||||
function HashFile($path){return(Get-FileHash -LiteralPath $path -Algorithm SHA256).Hash.ToLowerInvariant()}
|
||||
function Check($path,[bool]$dir,[string[]]$readers=@(),[string[]]$writers=@()){
|
||||
$i=Get-Item -LiteralPath $path -Force;if($i.PSIsContainer-ne$dir-or($i.Attributes-band[IO.FileAttributes]::ReparsePoint)){throw 'Regular fixed fixture'};$parent=$i.Parent;if(!$dir){$parent=$i.Directory};while($null-ne$parent){if($parent.Attributes-band[IO.FileAttributes]::ReparsePoint){throw 'Reparse ancestor'};$parent=$parent.Parent}
|
||||
$a=Get-Acl -LiteralPath $path;if(($a.GetOwner([Security.Principal.SecurityIdentifier]).Value-notin@($sys,$admin)-and!(!$dir-and$writers.Count-gt0-and$sids-and$writers[0]-ceq$sids[0]-and$a.GetOwner([Security.Principal.SecurityIdentifier]).Value-ceq'S-1-5-19'))-or($dir-and!$a.AreAccessRulesProtected)){throw 'Fixture owner/protection'}
|
||||
$rules=@($a.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier]));if(!$rules.Count){throw 'Empty fixture DACL'}
|
||||
foreach($r in $rules){$sid=$r.IdentityReference.Value;$rights=[int64]$r.FileSystemRights;if($r.AccessControlType-ne'Allow'-or($r.PropagationFlags-band[Security.AccessControl.PropagationFlags]::InheritOnly)){throw 'Fixture ACE'};if($sid-in@($sys,$admin)){if($rights-ne2032127){throw 'Trusted fixture rights'}}elseif($sid-in$writers){if($rights-ne2032127){throw 'Own role rights'}}elseif($sid-in$readers){if($rights-ne131241-and$rights-ne1179817){throw 'Reader rights'}}else{throw 'Foreign fixture ACE'}}
|
||||
}
|
||||
function NewDir($path,[string[]]$readers=@(),[string[]]$writers=@()){
|
||||
if(Test-Path -LiteralPath $path){throw 'Create-only fixture directory'};$a=New-Object Security.AccessControl.DirectorySecurity;$a.SetAccessRuleProtection($true,$false);$a.SetOwner((New-Object Security.Principal.SecurityIdentifier($admin)))
|
||||
foreach($sid in @($sys,$admin)+$writers){$a.AddAccessRule((New-Object Security.AccessControl.FileSystemAccessRule((New-Object Security.Principal.SecurityIdentifier($sid)),'FullControl','ContainerInherit,ObjectInherit','None','Allow')))}
|
||||
foreach($sid in @($readers|Where-Object{$_-notin$writers})){$a.AddAccessRule((New-Object Security.AccessControl.FileSystemAccessRule((New-Object Security.Principal.SecurityIdentifier($sid)),'ReadAndExecute','ContainerInherit,ObjectInherit','None','Allow')))}
|
||||
[IO.Directory]::CreateDirectory($path,$a)|Out-Null;Check $path $true $readers $writers
|
||||
}
|
||||
function WriteNew($path,$value){$raw=[Text.Encoding]::ASCII.GetBytes(($value|ConvertTo-Json -Depth 24 -Compress));if($raw.Length-gt65536){throw 'Bounded own controller record'};$f=[IO.File]::Open($path,[IO.FileMode]::CreateNew,[IO.FileAccess]::Write,[IO.FileShare]::Read);try{$f.Write($raw,0,$raw.Length);$f.Flush($true)}finally{$f.Dispose()};$a=New-Object Security.AccessControl.FileSecurity;$a.SetSecurityDescriptorSddlForm('O:BAG:BAD:P(A;;FA;;;SY)(A;;FA;;;BA)');Set-Acl -LiteralPath $path -AclObject $a}
|
||||
function ReadJson($path,[string[]]$readers=@(),[string[]]$writers=@(),[int]$limit=65536){Check $path $false $readers $writers;if((Get-Item -LiteralPath $path).Length-gt$limit){throw 'Bounded own JSON'};return([IO.File]::ReadAllText($path,[Text.Encoding]::UTF8)|ConvertFrom-Json)}
|
||||
function Command([int]$n){return('"'+$exe+'" --service '+$p.id+' '+$tags[$n])}
|
||||
function Service([int]$n){
|
||||
$s=Get-CimInstance Win32_Service -Filter ("Name='"+$names[$n]+"'") -OperationTimeoutSec 5;if(!$s){return $null}
|
||||
if($s.PathName-cne(Command $n)-or$s.StartMode-cne'Manual'-or$s.ServiceType-cne'Own Process'-or$s.StartName-cne$accounts[$n]-or@((Get-Service -Name $names[$n]).ServicesDependedOn).Count-ne0){throw 'Exact own fixture SCM configuration'}
|
||||
if((Get-ItemPropertyValue -LiteralPath ('HKLM:\SYSTEM\CurrentControlSet\Services\'+$names[$n]) -Name ServiceSidType)-ne1){throw 'Own service SID type'}
|
||||
$text=(@(& 'C:\Windows\System32\sc.exe' sdshow $names[$n])-join"`n").Trim();if($LASTEXITCODE-ne0-or!$text-or$text.Length-gt8192){throw 'Bounded own SCM DACL'}
|
||||
$security=New-Object Security.AccessControl.RawSecurityDescriptor($text);if(!$security.DiscretionaryAcl-or!($security.ControlFlags-band[Security.AccessControl.ControlFlags]::DiscretionaryAclProtected)){throw 'Protected own SCM DACL'}
|
||||
foreach($ace in $security.DiscretionaryAcl){if($ace.AceQualifier-ne'AccessAllowed'-or$ace.SecurityIdentifier.Value-notin@($sys,$admin)){throw 'Own service controllers only'}}
|
||||
return [ordered]@{command=$s.PathName;account=$s.StartName;start=$s.StartMode;type=$s.ServiceType;sid_type=1;acl_sha256=(HashBytes ([Text.Encoding]::ASCII.GetBytes($text)))}
|
||||
}
|
||||
function Equal($a,$b){return(($a|ConvertTo-Json -Depth 24 -Compress)-ceq($b|ConvertTo-Json -Depth 24 -Compress))}
|
||||
function Original([int]$n){$made=ReadJson (Join-Path $control ($tags[$n]+'-created.json'));$s=Service $n;if(!$s-or!(Equal $s $made.service)){throw 'Same original fixture definition'};return $s}
|
||||
function ReadAll{
|
||||
$roles=[ordered]@{};for($n=0;$n-lt2;$n++){$output=Join-Path $case $tags[$n];Check $output $true $sids @($sids[$n]);$reports=[ordered]@{};foreach($leaf in @('intent','report','end')){$path=Join-Path $output ($leaf+'.json');$reports[$leaf]=$null;if(Test-Path -LiteralPath $path){$reports[$leaf]=ReadJson $path $sids @($sids[$n]) 16384}};$s=Service $n;$status=$null;if($s){$h=[RmmCaptureControl]::OpenOwn($names[$n]);try{$status=$h.Read()}finally{$h.Dispose()}};$markers=[ordered]@{};foreach($leaf in @('created','start-attempt','process','timeout-attempt','exit','outcome','delete-attempt','deleted')){$path=Join-Path $control ($tags[$n]+'-'+$leaf+'.json');$markers[$leaf]=$null;if(Test-Path -LiteralPath $path){$markers[$leaf]=ReadJson $path}};$reportHash=$null;if($null-ne$reports.report){$reportHash=HashFile (Join-Path $output 'report.json')};$roles[$tags[$n]]=@{service=$s;status=$status;markers=$markers;reports=$reports;raw_report_sha256=$reportHash}}
|
||||
return @{id=$p.id;read_only=($p.action-ceq'read');roles=$roles;calibrated=$false;clock_authority=$false;no_rmm_jobs=$true}
|
||||
}
|
||||
'''+NATIVE+r'''
|
||||
if($PSCommandPath-cne(Join-Path (Join-Path $boot $p.script_sha256) 'SignedClockCaptureAcceptance.ps1')-or(HashFile $PSCommandPath)-cne$p.script_sha256){throw 'Actual exact executing controller'}
|
||||
if($p.action-ceq'read'-and!(Test-Path -LiteralPath $case)){@{id=$p.id;read_only=$true;remote_case_absent=$true}|ConvertTo-Json -Compress;exit 0}
|
||||
if($p.action-ceq'setup'){
|
||||
if((Test-Path -LiteralPath $base)-or(Service 0)-or(Service 1)){throw 'Existing capture namespace: original read only'}
|
||||
NewDir $base;NewDir $case;NewDir $control;WriteNew (Join-Path $control 'intent.json') $p;WriteNew (Join-Path $base 'active.json') @{id=$p.id;manifest_sha256=$p.manifest_sha256;script_sha256=$p.script_sha256;no_retry=$true}
|
||||
for($n=0;$n-lt2;$n++){WriteNew (Join-Path $control ($tags[$n]+'-create-attempt.json')) @{create_once=$true;command=(Command $n)};$account=$accounts[$n];if($n-eq1){$account=$null};$h=[RmmCaptureControl]::CreateOnce($names[$n],(Command $n),$account);$h.Dispose();WriteNew (Join-Path $control ($tags[$n]+'-created.json')) @{service=(Service $n);create_once=$true}}
|
||||
$sids=@();foreach($name in $names){$sids+=((New-Object Security.Principal.NTAccount('NT SERVICE',$name)).Translate([Security.Principal.SecurityIdentifier]).Value)}
|
||||
# Set exact explicit reader ACLs before putting any executable in this case.
|
||||
foreach($path in @($base,$case)){$a=New-Object Security.AccessControl.DirectorySecurity;$a.SetAccessRuleProtection($true,$false);$a.SetOwner((New-Object Security.Principal.SecurityIdentifier($admin)));foreach($sid in @($sys,$admin)){$a.AddAccessRule((New-Object Security.AccessControl.FileSystemAccessRule((New-Object Security.Principal.SecurityIdentifier($sid)),'FullControl','ContainerInherit,ObjectInherit','None','Allow')))};foreach($sid in $sids){$a.AddAccessRule((New-Object Security.AccessControl.FileSystemAccessRule((New-Object Security.Principal.SecurityIdentifier($sid)),'ReadAndExecute','ContainerInherit,ObjectInherit','None','Allow')))};Set-Acl -LiteralPath $path -AclObject $a;Check $path $true $sids}
|
||||
for($n=0;$n-lt2;$n++){NewDir (Join-Path $case $tags[$n]) $sids @($sids[$n])}
|
||||
$staged=Join-Path (Join-Path $boot $p.exe_sha256) 'SignedClockCapture.exe';if((Get-Item -LiteralPath $staged).Length-ne8566784-or(HashFile $staged)-cne$p.exe_sha256){throw 'Exact staged probe'}
|
||||
[IO.File]::Copy($staged,$exe,$false);$ea=New-Object Security.AccessControl.FileSecurity;$ea.SetAccessRuleProtection($true,$false);$ea.SetOwner((New-Object Security.Principal.SecurityIdentifier($admin)));foreach($sid in @($sys,$admin)){$ea.AddAccessRule((New-Object Security.AccessControl.FileSystemAccessRule((New-Object Security.Principal.SecurityIdentifier($sid)),'FullControl','Allow')))};foreach($sid in $sids){$ea.AddAccessRule((New-Object Security.AccessControl.FileSystemAccessRule((New-Object Security.Principal.SecurityIdentifier($sid)),'ReadAndExecute','Allow')))};Set-Acl -LiteralPath $exe -AclObject $ea;$f=[IO.File]::Open($exe,'Open','ReadWrite','Read');try{$f.Flush($true)}finally{$f.Dispose()};Check $exe $false $sids;if((HashFile $exe)-cne$p.exe_sha256){throw 'Exact own probe copy'}
|
||||
WriteNew (Join-Path $control 'setup-complete.json') @{id=$p.id;roles=$sids;exe_sha256=$p.exe_sha256};@{id=$p.id;setup=$true;calibrated=$false;clock_authority=$false}|ConvertTo-Json -Compress;exit 0
|
||||
}
|
||||
if($p.action-ceq'read'-and!(Test-Path -LiteralPath (Join-Path $control 'setup-complete.json'))){$raw=@();foreach($name in $names){$v=Get-CimInstance Win32_Service -Filter ("Name='"+$name+"'") -OperationTimeoutSec 5;$raw+=@{name=$name;present=[bool]$v;state=$(if($v){$v.State}else{$null});pid=$(if($v){[uint32]$v.ProcessId}else{0});definition_unverified=$true}};@{id=$p.id;read_only=$true;partial_setup=$true;own_services=$raw;calibrated=$false;clock_authority=$false}|ConvertTo-Json -Depth 8 -Compress;exit 0}
|
||||
$setup=ReadJson (Join-Path $control 'setup-complete.json');$sids=@($setup.roles);if($sids.Count-ne2-or@($sids|Where-Object{$_-notmatch'^S-1-5-80(-[0-9]+){5}$'}).Count-ne0-or$sids[0]-ceq$sids[1]){throw 'Original two fixture SIDs'}
|
||||
Check $base $true $sids;Check $case $true $sids;Check $control $true
|
||||
$i=ReadJson (Join-Path $control 'intent.json');foreach($field in @('id','profile','exe_sha256','exe_bytes','script_sha256','manifest_sha256')){if($i.$field-cne$p.$field){throw 'Original exact capture intent'}}
|
||||
$a=ReadJson (Join-Path $base 'active.json') $sids;if($a.id-cne$p.id-or$a.manifest_sha256-cne$p.manifest_sha256-or$a.script_sha256-cne$p.script_sha256){throw 'Same active capture case'}
|
||||
Check $exe $false $sids;if((Get-Item -LiteralPath $exe).Length-ne8566784-or(HashFile $exe)-cne$p.exe_sha256){throw 'Original immutable probe'}
|
||||
if($p.action-ceq'read'){ReadAll|ConvertTo-Json -Depth 32 -Compress;exit 0}
|
||||
$n=0;if($p.action-in@('start-system','cleanup-system')){$n=1};$tag=$tags[$n];$output=Join-Path $case $tag
|
||||
$null=Original $n
|
||||
if($p.action-in@('start-local-service','start-system')){
|
||||
if((Test-Path -LiteralPath (Join-Path $control 'local-service-delete-attempt.json'))-or(Test-Path -LiteralPath (Join-Path $control 'system-delete-attempt.json'))){throw 'Campaign cleanup began; no further starts'}
|
||||
if(Test-Path -LiteralPath (Join-Path $control ($tag+'-start-attempt.json'))){throw 'Start already attempted; read only'}
|
||||
if($n-eq1){$first=ReadJson (Join-Path $control 'local-service-outcome.json');if($first.success-ne$true){throw 'LocalService must complete first'}}
|
||||
$h=[RmmCaptureControl]::OpenOwn($names[$n]);$process=$null;$proof=$null;$timed=$false;$start=[RmmCaptureControl]::GetTickCount64()
|
||||
try{
|
||||
if($h.Read().State-ne1){throw 'Own service initially stopped'}
|
||||
WriteNew (Join-Path $control ($tag+'-start-attempt.json')) @{start_once=$true;service=(Original $n)}
|
||||
$h.StartOnce()
|
||||
do{
|
||||
$state=$h.Read()
|
||||
if($state.Pid-gt0-and$null-eq$process){$process=[RmmCaptureControl]::Hold([int]$state.Pid);$proof=[RmmPipeNative]::Proof($process,[int]$state.Pid,$owners[$n],$sids[$n],$exe);$cli=(Get-CimInstance Win32_Process -Filter ('ProcessId='+$state.Pid) -OperationTimeoutSec 5).CommandLine;if($cli-cne(Command $n)-or![RmmPipeNative]::Alive($process)-or$h.Read().Pid-ne$state.Pid){throw 'Exact own process CLI/generation'};WriteNew (Join-Path $control ($tag+'-process.json')) @{proof=$proof;command=$cli;image_sha256=$p.exe_sha256}}
|
||||
if($state.State-eq1){break}
|
||||
if([RmmCaptureControl]::GetTickCount64()-$start-ge40000){$timed=$true;break}
|
||||
if($null-ne$process){$null=[RmmPipeNative]::Exited($process,25)}else{Start-Sleep -Milliseconds 10}
|
||||
}while($true)
|
||||
if($timed){if($null-eq$process-or$null-eq$proof){throw 'Timeout without held process; manual original read only'};$fresh=[RmmPipeNative]::Proof($process,[int]$proof.pid,$owners[$n],$sids[$n],$exe);if($fresh.creation_filetime-cne$proof.creation_filetime-or$h.Read().Pid-ne$proof.pid-or(Original $n).command-cne(Command $n)){throw 'Timeout target changed; no termination'};$cli=(Get-CimInstance Win32_Process -Filter ('ProcessId='+$proof.pid) -OperationTimeoutSec 5).CommandLine;if($cli-cne(Command $n)){throw 'Timeout CLI changed'};WriteNew (Join-Path $control ($tag+'-timeout-attempt.json')) @{proof=$proof;terminate_own_handle_once=$true};[RmmCaptureControl]::KillHeld($process)}
|
||||
if($null-eq$process-or![RmmPipeNative]::Exited($process,5000)){throw 'Own process exit not bound'}
|
||||
$exit=[RmmCaptureControl]::Exit($process);$state=$h.Read();if($state.State-ne1){throw 'Own SCM stop not observed'};WriteNew (Join-Path $control ($tag+'-exit.json')) @{process=$proof;kernel_process_exited=$true;exit_code=$exit;timed_out=$timed;scm_exit=$state.Win32Exit;scm_specific_exit=$state.SpecificExit}
|
||||
$report=ReadJson (Join-Path $output 'report.json') $sids @($sids[$n]) 16384;$end=ReadJson (Join-Path $output 'end.json') $sids @($sids[$n]) 16384;$intent=ReadJson (Join-Path $output 'intent.json') $sids @($sids[$n]) 16384
|
||||
if($timed-or$exit-ne0-or$state.Win32Exit-ne0-or$state.SpecificExit-ne0-or$end.success-ne$true-or$report.pid-ne$proof.pid-or[string]$report.process_birth_filetime-cne$proof.creation_filetime-or$report.image_sha256-cne$p.exe_sha256-or$report.role-cne$tag-or$report.case_id-cne$p.id-or$intent.pid-ne$report.pid-or$intent.process_birth_filetime-ne$report.process_birth_filetime-or$end.case_id-cne$p.id-or$end.role-cne$tag-or$report.calibrated-ne$false-or$report.clock_authority-ne$false-or$report.capture.calibrated-ne$false-or$report.capture.clock_authority-ne$false-or$report.capture.sample_count-ne128-or@($report.capture.samples_100ns).Count-ne128-or$report.capture.elapsed_monotonic_ns-gt250000000-or$report.capture.elapsed_interrupt_ns-gt250000000-or$end.report_sha256-cne(HashFile (Join-Path $output 'report.json'))){throw 'Exact noncalibrating report/end/exit proof'}
|
||||
WriteNew (Join-Path $control ($tag+'-outcome.json')) @{success=$true;exit_code=$exit;process=$proof;scm_exit=$state.Win32Exit;scm_specific_exit=$state.SpecificExit;report_sha256=$end.report_sha256;calibrated=$false;clock_authority=$false}
|
||||
}finally{if($null-ne$process){$process.Dispose()};$h.Dispose()}
|
||||
ReadAll|ConvertTo-Json -Depth 32 -Compress;exit 0
|
||||
}
|
||||
if($p.action-in@('cleanup-local-service','cleanup-system')){
|
||||
if(Test-Path -LiteralPath (Join-Path $control ($tag+'-delete-attempt.json'))){throw 'Delete already attempted; read only'}
|
||||
if(Test-Path -LiteralPath (Join-Path $control ($tag+'-start-attempt.json'))){$exited=ReadJson (Join-Path $control ($tag+'-exit.json'));$originalProcess=ReadJson (Join-Path $control ($tag+'-process.json'));if($exited.kernel_process_exited-ne$true-or!(Equal $exited.process $originalProcess.proof)){throw 'Original started process exit not durably observed'}}
|
||||
$h=[RmmCaptureControl]::OpenOwn($names[$n]);try{if($h.Read().State-ne1){throw 'Cleanup only stopped original service'};$null=Original $n;WriteNew (Join-Path $control ($tag+'-delete-attempt.json')) @{delete_once=$true;service=(Original $n)};$h.DeleteOnce()}finally{$h.Dispose()}
|
||||
if(Service $n){throw 'Service absence not observed; read only'};WriteNew (Join-Path $control ($tag+'-deleted.json')) @{deleted=$true;service_absent=$true;id=$p.id}
|
||||
ReadAll|ConvertTo-Json -Depth 32 -Compress;exit 0
|
||||
}
|
||||
throw 'Fixed capture phase only'
|
||||
'''
|
||||
|
||||
LAUNCH = r'''$ErrorActionPreference='Stop';$p=([Console]::In.ReadLine()|ConvertFrom-Json)
|
||||
if($p.script_sha256-notmatch'^[a-f0-9]{64}$'-or$p.id-notmatch'^[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$'-or$p.action-notin@('setup','start-local-service','start-system','read','cleanup-local-service','cleanup-system')){throw 'Fixed controller request'}
|
||||
$script='C:\ProgramData\RustDiscoveryBootstrap\'+$p.script_sha256+'\SignedClockCaptureAcceptance.ps1'
|
||||
if(!(Test-Path -LiteralPath $script)){
|
||||
if($p.action-cne'read'){throw 'Staged controller absent'}
|
||||
@{id=$p.id;read_only=$true;controller_absent=$true;remote_case_absent=!(Test-Path -LiteralPath ('C:\ProgramData\RustDiscoverySignedClockCapture\'+$p.id))}|ConvertTo-Json -Compress;exit 0
|
||||
}
|
||||
$i=Get-Item -LiteralPath $script -Force;if($i.PSIsContainer-or($i.Attributes-band[IO.FileAttributes]::ReparsePoint)-or$i.Length-gt65536-or(Get-FileHash -LiteralPath $script -Algorithm SHA256).Hash.ToLowerInvariant()-cne$p.script_sha256){throw 'Exact staged controller'}
|
||||
$a=Get-Acl -LiteralPath $script;if($a.GetOwner([Security.Principal.SecurityIdentifier]).Value-notin@('S-1-5-18','S-1-5-32-544')){throw 'Controller owner'};foreach($r in $a.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier])){if($r.AccessControlType-ne'Allow'-or$r.IdentityReference.Value-notin@('S-1-5-18','S-1-5-32-544')){throw 'Private controller DACL'}}
|
||||
$global:RmmSignedClockCapturePayload=$p
|
||||
& $script
|
||||
'''
|
||||
|
||||
|
||||
class CaptureAccess(pipe.Access):
|
||||
def stage_capture(self, path, name):
|
||||
require(name in ('SignedClockCapture.exe', 'SignedClockCaptureAcceptance.ps1'), 'two fixed capture artifacts only')
|
||||
path = Path(path)
|
||||
private(path)
|
||||
size = path.stat().st_size
|
||||
require(size == EXE_BYTES if name.endswith('.exe') else size <= 65536, 'fixed bounded capture transfer')
|
||||
digest = sha(path)
|
||||
prepare = pipe.u.transport.PREPARE_SCRIPT.replace('TransportAcceptance.ps1', name)
|
||||
observed = self.powershell(prepare, dict(sha256=digest))
|
||||
if not observed['already_uploaded']:
|
||||
# Credentials are read only by the actual operator phase. The
|
||||
# existing strict pinned ssh prefix is reused without modification.
|
||||
access = pipe.cb.contract.protected_json(self.root / 'credentials/windows-dev-access.json')
|
||||
prefix = access['ssh_prefix']
|
||||
args = ['sftp'] + [p for p in prefix[1:-1] if p != '-T'] + ['-b', '-', prefix[-1]]
|
||||
target = '/C:/ProgramData/RustDiscoveryBootstrap/' + digest + '/' + name
|
||||
result = subprocess.run(args, input=('put ' + json.dumps(str(path.resolve())) + ' ' + json.dumps(target) + '\n').encode(), capture_output=True, timeout=60)
|
||||
require(result.returncode == 0, 'fixed create-once capture transfer; lost reply read only')
|
||||
observed = self.powershell(prepare, dict(sha256=digest))
|
||||
require(observed['already_uploaded'] is True and observed['sha256'] == digest, 'exact immutable staged capture artifact')
|
||||
|
||||
|
||||
def dependencies():
|
||||
paths = set(pipe.dependencies()) | {'deploy/windows/system_pipe_upgrade.py'}
|
||||
return {path: sha(ROOT / path) for path in sorted(paths)}
|
||||
|
||||
|
||||
def original_main():
|
||||
for name, digest in INDEX_SHAS.items():
|
||||
path = ACCESS_ROOT / 'devstate/windows-client' / name
|
||||
require(sha(path) == digest, 'unchanged accepted Main component indices')
|
||||
require(sha(MAIN_CASE / 'intent.json') == MAIN_INTENT_SHA and sha(MAIN_CASE / 'result.json') == MAIN_RESULT_SHA, 'original accepted 14fb proof')
|
||||
intent = load(MAIN_CASE / 'intent.json')
|
||||
require(intent['script_sha256'] == pipe.raw_sha(pipe.SCRIPT.encode()), 'original 14fb read-only finish implementation')
|
||||
return intent
|
||||
|
||||
|
||||
def source_qualification():
|
||||
require(sha(QUALIFICATION / 'receipt.json') == RECEIPT_SHA and sha(QUALIFICATION / 'inputs.json') == INPUTS_SHA
|
||||
and sha(QUALIFICATION / 'readonly-capabilities.json') == CAP_SHA, 'original reviewed raw source qualification')
|
||||
inputs = load(QUALIFICATION / 'inputs.json')
|
||||
receipt = load(QUALIFICATION / 'receipt.json')
|
||||
require(len(inputs) == 190 and receipt['calibrated'] is False and receipt['clock_authority'] is False
|
||||
and receipt['module_sha256'] == 'd9dd843db7c17ac4c8f242c9f20063c2a7ce6ad11d3c75826516a22dc5e7685e'
|
||||
and receipt['example_sha256'] == '23f7c8d832bf9042fb89226729aa1cfe2a65ad33b76cda15cc69f8995d5834d0', 'reviewed exact non-authoritative probe')
|
||||
seen = set()
|
||||
for item in inputs:
|
||||
path = Path(item['path'])
|
||||
require(not path.is_absolute() and '..' not in path.parts and str(path) not in seen, 'unique frozen relative input')
|
||||
seen.add(str(path))
|
||||
file = QUALIFICATION / 'source' / path
|
||||
metadata = file.lstat()
|
||||
require(stat.S_ISREG(metadata.st_mode) and metadata.st_nlink == 1 and metadata.st_size == item['bytes']
|
||||
and metadata.st_size <= 2 * 1024 * 1024 and sha(file) == item['sha256'], 'original frozen source bytes')
|
||||
binary = QUALIFICATION / 'SignedClockCapture.exe'
|
||||
require(binary.stat().st_size == EXE_BYTES and sha(binary) == EXE_SHA, 'exact qualified AMD64 probe')
|
||||
native = load(LINUX_READ)
|
||||
require(sha(LINUX_READ) == LINUX_READ_SHA and native['read_only'] is True and native['entered'] is True
|
||||
and native['id'] == NATIVE_CASE.name, 'actual original Linux-first pass readback')
|
||||
result = native['result']
|
||||
require(result['passed'] == 5 and result['listed'] == 15 and result['filtered'] == 10 and result['ignored'] == 0
|
||||
and result['source_receipt_sha256'] == RECEIPT_SHA and result['source_manifest_sha256'] == sha(NATIVE_CASE / 'manifest.json')
|
||||
and result['before'] == result['after'] == native['current_witness'] and result['no_rmm_jobs'] is True
|
||||
and result['no_service_control'] is True and result['binary_sha256'] == 'dceee96d9e58d8b5c3606c724b4d390c2eea6472bf33d317e7a5a9102c0c5e06', 'actual five Linux guards and retained original state')
|
||||
native_manifest = load(NATIVE_CASE / 'manifest.json')
|
||||
require(native_manifest['source_files'] == inputs and native_manifest['receipt_sha256'] == RECEIPT_SHA, 'same Linux proof source generation')
|
||||
return inputs
|
||||
|
||||
|
||||
def prepare():
|
||||
original_main()
|
||||
inputs = source_qualification()
|
||||
STATE.mkdir(mode=0o700, parents=True, exist_ok=True); private(STATE, True)
|
||||
ident = str(uuid.uuid4())
|
||||
# One original campaign for this exact frozen source. An incomplete case
|
||||
# cannot be bypassed by asking prepare for another UUID.
|
||||
save(STATE / 'active-intent.json', dict(id=ident, runner_sha256=sha(__file__), no_retry=True))
|
||||
folder = STATE / ident; folder.mkdir(mode=0o700)
|
||||
for name in ('receipt.json', 'inputs.json', 'readonly-capabilities.json'):
|
||||
write(folder / name, (QUALIFICATION / name).read_bytes())
|
||||
for item in inputs:
|
||||
destination = folder / 'source' / item['path']
|
||||
destination.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
|
||||
write(destination, (QUALIFICATION / 'source' / item['path']).read_bytes())
|
||||
write(folder / 'SignedClockCapture.exe', (QUALIFICATION / 'SignedClockCapture.exe').read_bytes())
|
||||
write(folder / 'SignedClockCaptureAcceptance.ps1', SCRIPT.encode())
|
||||
write(folder / 'linux-first-read.json', LINUX_READ.read_bytes())
|
||||
manifest = dict(id=ident, profile=PROFILE, runner_sha256=sha(__file__), dependencies=dependencies(),
|
||||
source_files=inputs, source_receipt_sha256=RECEIPT_SHA, readonly_capabilities_sha256=CAP_SHA,
|
||||
exe_sha256=EXE_SHA, exe_bytes=EXE_BYTES, script_sha256=hashlib.sha256(SCRIPT.encode()).hexdigest(),
|
||||
linux_first_read_sha256=LINUX_READ_SHA, main_indices=INDEX_SHAS, main_result_sha256=MAIN_RESULT_SHA,
|
||||
calibrated=False, clock_authority=False, target_executed=False)
|
||||
save(folder / 'manifest.json', manifest)
|
||||
print(json.dumps(dict(id=ident, prepared_locally=True, target_executed=False)))
|
||||
|
||||
|
||||
def case(ident):
|
||||
require(str(uuid.UUID(ident)) == ident and uuid.UUID(ident).version == 4, 'original canonical UUIDv4')
|
||||
folder = STATE / ident; private(folder, True)
|
||||
manifest = load(folder / 'manifest.json')
|
||||
require(manifest['id'] == ident and manifest['profile'] == PROFILE and manifest['runner_sha256'] == sha(__file__)
|
||||
and manifest['dependencies'] == dependencies() and load(STATE / 'active-intent.json')['id'] == ident, 'original source and active case only')
|
||||
require(sha(folder / 'SignedClockCapture.exe') == EXE_SHA and (folder / 'SignedClockCapture.exe').stat().st_size == EXE_BYTES
|
||||
and sha(folder / 'SignedClockCaptureAcceptance.ps1') == manifest['script_sha256'] == hashlib.sha256(SCRIPT.encode()).hexdigest()
|
||||
and sha(folder / 'receipt.json') == RECEIPT_SHA and sha(folder / 'inputs.json') == INPUTS_SHA
|
||||
and sha(folder / 'readonly-capabilities.json') == CAP_SHA and sha(folder / 'linux-first-read.json') == LINUX_READ_SHA, 'same exact original sources/proofs/artifacts')
|
||||
require(manifest['source_files'] == load(folder / 'inputs.json') and len(manifest['source_files']) == 190, 'fixed original source manifest')
|
||||
for item in manifest['source_files']:
|
||||
relative = Path(item['path'])
|
||||
require(not relative.is_absolute() and '..' not in relative.parts, 'fixed relative source path')
|
||||
path = folder / 'source' / relative; private(path)
|
||||
require(path.stat().st_size == item['bytes'] and sha(path) == item['sha256'], 'original retained 190 input bytes')
|
||||
original_main()
|
||||
return folder, manifest
|
||||
|
||||
|
||||
def server_closed(access):
|
||||
observed = access.server_state()
|
||||
require(observed['counts'] == dict(windows=dict(jobs=0, outbox=0, permits=0, unresolved=0),
|
||||
linux=dict(jobs=31, outbox=31, permits=27, unresolved=0))
|
||||
and observed['flags']['root_policy_sha256'] == ROOT_POLICY, 'actual accepted current counts and closed Rootpolicy')
|
||||
return observed
|
||||
|
||||
|
||||
def native_witness(access):
|
||||
observed = pipe.remote(access, original_main(), 'finish')
|
||||
require(observed['read_only'] is True and observed['completed'] is True, 'only original existing 14fb finish reader')
|
||||
native = observed['native']
|
||||
require(native['private_key_read'] is False and all(value == 0 for value in native['journal']['core_counts'].values()), 'passive identity, no core job rows')
|
||||
return dict(stable={field: native[field] for field in STABLE}, journal={field: native['journal'][field] for field in JOURNAL},
|
||||
sequence=native['journal']['sequence'])
|
||||
|
||||
|
||||
def preserved(before, after):
|
||||
require(before['stable'] == after['stable'] and before['journal'] == after['journal']
|
||||
and after['sequence'] >= 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()
|
||||
@@ -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,
|
||||
|
||||
@@ -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 <voller 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/<UUID>` 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 <UUID>` 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 <UUID>`. 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 <UUID> --sha256 <Archivhash>` 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 <UUID>` 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 <UUID> --sha256 <Probe-ELF-hash>`. 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 <UUID>` 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/<chrony>/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.
|
||||
@@ -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 <Original-UUID>
|
||||
python3 deploy/windows/signed_clock_capture_acceptance.py setup --case <Original-UUID>
|
||||
python3 deploy/windows/signed_clock_capture_acceptance.py start-local-service --case <Original-UUID>
|
||||
python3 deploy/windows/signed_clock_capture_acceptance.py start-system --case <Original-UUID>
|
||||
python3 deploy/windows/signed_clock_capture_acceptance.py read --case <Original-UUID>
|
||||
python3 deploy/windows/signed_clock_capture_acceptance.py cleanup-local-service --case <Original-UUID>
|
||||
python3 deploy/windows/signed_clock_capture_acceptance.py cleanup-system --case <Original-UUID>
|
||||
python3 deploy/windows/signed_clock_capture_acceptance.py read --case <Original-UUID>
|
||||
```
|
||||
|
||||
`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\<UUID>`, 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.
|
||||
Reference in New Issue
Block a user