test: qualify MIDL diagnostic build and record native access denial
Rust development slice / linux (push) Failing after 7s

This commit is contained in:
2026-11-14 16:20:57 +01:00
parent 35600dc472
commit 85f6ecc1c7
5 changed files with 789 additions and 0 deletions
@@ -0,0 +1,27 @@
[workspace]
[package]
name = "rmm-clock-midl-diagnostic"
version = "0.1.0"
edition = "2024"
license = "AGPL-3.0-only"
autobins = false
[[bin]]
name = "clock-midl-readiness"
path = "../../../crates/agent-windows/examples/clock_readiness.rs"
[dependencies]
anyhow = "1.0.100"
chrono = { version = "0.4.42", features = ["serde"] }
serde = { version = "1.0.228", features = ["derive"] }
serde_json = "1.0.145"
uuid = { version = "1.18.1", features = ["v4", "serde"] }
rmm-agent-core = { path = "../../../crates/agent-core" }
[build-dependencies]
cc = "=1.11.1"
sha2 = "0.10.9"
[target.'cfg(windows)'.dependencies]
windows-sys = { version = "0.61.2", features = ["Win32_Foundation", "Win32_Security", "Win32_Security_Authorization", "Win32_Storage_FileSystem", "Win32_System_IO", "Win32_System_JobObjects", "Win32_System_Pipes", "Win32_System_SystemInformation", "Win32_System_Registry", "Win32_System_Memory", "Win32_System_Services", "Win32_System_Threading"] }
@@ -0,0 +1,93 @@
//! Separate diagnostic only: actual Microsoft outputs from native case 149bafe2.
//! No generator execution/fallback, NDR edits, header-version overrides or
//! modification of the product crate's build script/output directory.
use sha2::{Digest, Sha256};
use std::{env, fs, path::Path};
fn pinned(path: &Path, expected: &str) {
let bytes = fs::read(path).expect("missing pinned diagnostic input");
assert_eq!(
format!("{:x}", Sha256::digest(bytes)),
expected,
"diagnostic input changed: {}",
path.display()
);
println!("cargo:rerun-if-changed={}", path.display());
}
fn main() {
let here = env::current_dir().unwrap();
let root = here.join("../../..");
for (name, digest) in [
(
"examples/clock_readiness.rs",
"77433fafc9891ada53571bc070e33b9c9998379b7dadf48c1e19dc3851e44fe7",
),
(
"src/clock.rs",
"08b983095015cc7ba08ce08e9436d1519bf720c5501dd7af8b8b3dbae56b356f",
),
(
"native/clock_rpc.c",
"74aceb6e2b70c5dd628fae069a842c356c20300b8c8ab12754258c78eaf295c8",
),
(
"native/clock_endpoints.c",
"85c563bc8824bc30f7e80ef36e3dae5548c1f7a94faf5e882e98f275ab9a55e7",
),
(
"native/w32time.idl",
"37da4acb622daf9acf1aa6f1218ff9f52e5a2def14e58d8d9dd8da65078b3c6c",
),
] {
pinned(&root.join("crates/agent-windows").join(name), digest);
}
let generated = here.join("generated");
pinned(
&generated.join("w32time.h"),
"db5dbe5b335eaa58a6512d4abfda44e7273f3aa8a43077dcb0719e4b97ee2bde",
);
pinned(
&generated.join("w32time_c.c"),
"d806adb431f16724c8afdea0c0751588a4bc6f82b6f0b8391d4d189d6a6f4a38",
);
if env::var("CARGO_CFG_TARGET_OS").as_deref() != Ok("windows") {
return;
}
assert_eq!(env::var("TARGET").as_deref(), Ok("x86_64-pc-windows-gnu"));
// Microsoft guards its AMD64 stub using this architecture macro. Clang's
// GNU target does not predefine it. This declares the actual selected x64
// architecture; no SDK/RPCNDR version or _MSC_VER is fabricated.
cc::Build::new()
.compiler("clang")
.flag("--target=x86_64-w64-windows-gnu")
.flag("-fms-extensions")
.flag("-Werror")
.define("_M_AMD64", Some("100"))
.include(&generated)
.file(root.join("crates/agent-windows/native/clock_rpc.c"))
.file(root.join("crates/agent-windows/native/clock_endpoints.c"))
.compile("rmm_clock_rpc");
// MIDL's unchanged descriptor initializer uses legal C brace elision for
// MinGW's union field and emits two unused const tables. Keep these style
// warnings visible only for this pinned generated unit; do not edit NDR
// data, suppress type/security errors, or weaken wrapper diagnostics.
cc::Build::new()
.compiler("clang")
.flag("--target=x86_64-w64-windows-gnu")
.flag("-fms-extensions")
.flag("-Werror")
.flag("-Wno-error=missing-braces")
.flag("-Wno-error=unused-const-variable")
.define("_M_AMD64", Some("100"))
.include(&generated)
.file(generated.join("w32time_c.c"))
.compile("rmm_clock_midl_stub");
println!("cargo:rustc-link-lib=rpcrt4");
println!("cargo:rustc-link-lib=advapi32");
// The existing GNU readiness artifact imports both precise interrupt-time
// getters through the Windows realtime API set. This SDK's kernel32 import
// archive omits them; its mincore archive supplies those same OS imports.
// No clock implementation, API fallback or generated code is substituted.
println!("cargo:rustc-link-lib=mincore");
}
@@ -0,0 +1,153 @@
#!/usr/bin/env python3
"""Local-only, separate MIDL readiness crossbuild. Never accesses a VM.
Preserves all existing runners, product sources, generated outputs and evidence.
Each invocation creates a fresh source snapshot and records failed checks too.
"""
import base64
import hashlib
import json
import os
from pathlib import Path
import re
import shutil
import subprocess
import uuid
ROOT = Path(__file__).resolve().parents[2]
PACKAGE = Path('deploy/windows/clock-midl-diagnostic')
IMAGE = 'sha256:1b2fd985d2c1fcc3545ace602405dc68fa899201bd8a73fa319ff96377203fa9'
CODEGEN = ROOT / 'devstate/windows-clock-midl/native-cases/149bafe2-3469-4580-b133-988812bcc3db'
READBACK = 'readback-059c15ef-0f31-41aa-ad1d-ea6b774280d7.json'
READBACK_SHA = '0dc2373825f7f8f224cda04ecd5c521dd3c37a6e712bc3ed83bc4fa6d0d89c8c'
PINNED = {
'w32time.h': 'db5dbe5b335eaa58a6512d4abfda44e7273f3aa8a43077dcb0719e4b97ee2bde',
'w32time_c.c': 'd806adb431f16724c8afdea0c0751588a4bc6f82b6f0b8391d4d189d6a6f4a38',
}
def sha(raw):
return hashlib.sha256(raw).hexdigest()
def require(condition, message):
if not condition:
raise RuntimeError(message)
def write_new(path, raw):
path.parent.mkdir(parents=True, exist_ok=True)
with path.open('xb') as out:
out.write(raw)
out.flush()
os.fsync(out.fileno())
def save(path, value):
write_new(path, (json.dumps(value, indent=2) + '\n').encode())
def compiler_inputs():
paths = [ROOT / name for name in ('Cargo.toml', 'Cargo.lock', 'rust-toolchain.toml')]
paths += [p for p in (ROOT / 'crates').rglob('*') if p.is_file() and p.suffix in ('.rs', '.toml', '.c', '.idl')]
paths += [p for p in (ROOT / 'proto').rglob('*') if p.is_file()]
paths += [ROOT / PACKAGE / name for name in ('Cargo.toml', 'build.rs')]
paths += [Path(__file__).resolve()]
require(all(not p.is_symlink() for p in paths), 'compiler input symlink')
return {str(p.relative_to(ROOT)): sha(p.read_bytes()) for p in sorted(paths)}
def external_packages(lock):
# Only compare Cargo-generated fixed string fields; never execute TOML.
result = set()
for block in lock.split('[[package]]')[1:]:
fields = dict(re.findall(r'^(name|version|source|checksum) = "([^"\n]+)"$', block, re.M))
if 'source' in fields:
require(set(fields) == {'name', 'version', 'source', 'checksum'}, 'unrecognized external lock entry')
result.add(tuple(fields[key] for key in ('name', 'version', 'source', 'checksum')))
return result
def main():
os.umask(0o077)
before = compiler_inputs()
receipt_raw = (CODEGEN / READBACK).read_bytes()
require(sha(receipt_raw) == READBACK_SHA, 'original native readback hash changed')
receipt = json.loads(receipt_raw)
result = receipt['result']
require(receipt['readback_only'] is True and result['complete'] is True and result['no_rpc'] is True
and result['run']['exit_code'] == 0 and result['run']['all_own_children_exited'] is True
and result['clock_qualified'] is False, 'native codegen readback incomplete')
ident = str(uuid.uuid4())
case = ROOT / 'devstate/windows-clock-midl/diagnostic-builds' / ident
case.mkdir(parents=True, mode=0o700)
source = case / 'source'
source.mkdir(mode=0o700)
for name, digest in before.items():
raw = (ROOT / name).read_bytes()
require(sha(raw) == digest, 'source changed during snapshot')
write_new(source / name, raw)
for name, digest in PINNED.items():
raw = (CODEGEN / ('native-' + name)).read_bytes()
original = next(item for item in receipt['files'] if item['name'] == name)
require(sha(raw) == digest == original['sha256'] and len(raw) == original['bytes']
and base64.b64decode(original['base64'], validate=True) == raw, 'actual Microsoft output differs')
write_new(source / PACKAGE / 'generated' / name, raw)
write_new(source / PACKAGE / 'Cargo.lock', (ROOT / 'Cargo.lock').read_bytes())
save(case / 'intent.json', dict(id=ident, image=IMAGE, native_case=str(CODEGEN), native_readback_sha256=READBACK_SHA,
source_files=before, microsoft_generated=PINNED, no_vm=True, no_jobs=True,
production_clock_qualified=False))
print('Retained local MIDL diagnostic build ' + ident, flush=True)
checks = {}
def run(name, args):
command = ['docker', 'run', '--rm', '--network', 'none', '--read-only', '--tmpfs', '/tmp:rw,size=512m',
'-v', str(source) + ':/src:ro', '-v', str(case / 'target') + ':/target',
'-v', str(case) + ':/evidence', '-e', 'CARGO_TARGET_DIR=/target',
'--entrypoint', args[0], IMAGE] + args[1:]
with (case / (name + '.log')).open('xb') as output:
completed = subprocess.run(command, stdout=output, stderr=subprocess.STDOUT, timeout=600)
checks[name] = dict(exit_code=completed.returncode, command=command, log_sha256=sha((case / (name + '.log')).read_bytes()))
save(case / (name + '.check.json'), checks[name])
require(completed.returncode == 0, 'local check failed: ' + name)
print(name + ' PASS', flush=True)
manifest = '/src/' + str(PACKAGE / 'Cargo.toml')
# Resolve only the new diagnostic leaf against the existing locked versions.
# Snapshot manifest directory is temporarily a private writable mount for
# this sole metadata step; the source worktree is never writable in Docker.
writable = case / 'lock-resolution'
shutil.copytree(source, writable)
metadata_command = ['docker', 'run', '--rm', '--network', 'none', '--read-only', '--tmpfs', '/tmp:rw,size=128m',
'-v', str(writable) + ':/src', '--entrypoint', 'cargo', IMAGE, 'metadata',
'--manifest-path', manifest, '--offline', '--format-version', '1']
with (case / 'lock-resolution.log').open('xb') as output:
lock_result = subprocess.run(metadata_command, stdout=output, stderr=subprocess.STDOUT, timeout=120)
require(lock_result.returncode == 0, 'diagnostic lock resolution failed')
resolved = (writable / PACKAGE / 'Cargo.lock').read_bytes()
require(external_packages(resolved.decode()).issubset(external_packages((ROOT / 'Cargo.lock').read_text())), 'new external dependency version')
# Replace only our freshly copied diagnostic lock BEFORE build admission;
# this is never an edit to generated NDR/header data or an OUT_DIR patch.
(source / PACKAGE / 'Cargo.lock').write_bytes(resolved)
save(case / 'resolved-lock.json', dict(sha256=sha(resolved), no_new_external_versions=True))
run('fmt', ['cargo', 'fmt', '--manifest-path', manifest, '--', '--check'])
run('clippy-windows', ['cargo', 'clippy', '--manifest-path', manifest, '--locked', '--offline', '--target', 'x86_64-pc-windows-gnu', '--all-targets', '--', '-D', 'warnings'])
run('linux-clock-tests', ['cargo', 'test', '--manifest-path', manifest, '--locked', '--offline', '--bin', 'clock-midl-readiness', '--', '--test-threads=1'])
require('test result: ok. 5 passed; 0 failed; 0 ignored;' in (case / 'linux-clock-tests.log').read_text(), 'actual five clock tests required')
run('windows-test-link', ['cargo', 'build', '--manifest-path', manifest, '--locked', '--offline', '--target', 'x86_64-pc-windows-gnu', '--tests'])
run('release-link', ['cargo', 'build', '--manifest-path', manifest, '--locked', '--offline', '--target', 'x86_64-pc-windows-gnu', '--release', '--bin', 'clock-midl-readiness'])
run('artifact', ['sh', '-c', 'cp /target/x86_64-pc-windows-gnu/release/clock-midl-readiness.exe /evidence/WindowsClockReadiness.linked.exe && cp /evidence/WindowsClockReadiness.linked.exe /evidence/WindowsClockReadiness.exe && x86_64-w64-mingw32-strip /evidence/WindowsClockReadiness.exe && x86_64-w64-mingw32-objdump -p /evidence/WindowsClockReadiness.exe'])
require(compiler_inputs() == before, 'source inputs changed during diagnostic build')
executable = case / 'WindowsClockReadiness.exe'
qualification = dict(id=ident, source_files=before, source_before_after_identical=True, image=IMAGE,
native_codegen_case=CODEGEN.name, native_readback_sha256=READBACK_SHA,
generated_inputs=PINNED, checks=checks, artifact=dict(path=str(executable), sha256=sha(executable.read_bytes()), bytes=executable.stat().st_size),
linked_binary_sha256=sha((case / 'WindowsClockReadiness.linked.exe').read_bytes()),
linux_clock_test_count=5, native_windows_execution=False, native_cloud_linux_execution=False,
production_clock_qualified=False, no_vm=True, no_jobs=True)
save(case / 'qualification.json', qualification)
print(json.dumps(dict(id=ident, artifact=qualification['artifact'], qualification_sha256=sha((case / 'qualification.json').read_bytes()), no_vm=True, clock_qualified=False)))
if __name__ == '__main__':
main()
+279
View File
@@ -0,0 +1,279 @@
#!/usr/bin/env python3
"""Package existing five portable clock units; only Root invokes native phases.
No build, Windows/NDR execution, RMM daemon, service, policy, DB or job action.
Lost native replies permit readback of the same case only, never another run.
"""
import argparse
import base64
import hashlib
import inspect
import json
import os
from pathlib import Path
import re
import shutil
import subprocess
import sys
import uuid
ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT / 'deploy'))
import remote_client_bootstrap as linux
import vm_mvp_acceptance as contract
CASE = ROOT / 'devstate/windows-clock-midl/diagnostic-builds/181c3a1c-8324-41fd-9b7c-aa8010262912'
QUALIFICATION_SHA = '2e0de3acf72ab5c3a8e0baa54e8643d086ea7c03d1b38fd89b6bfc00e45f8cbb'
STATE = ROOT / 'devstate/windows-clock-midl/linux-native-packs'
REMOTE = '/var/lib/rmm-clock-midl-portable-tests'
TESTS = (
'clock::tests::gate_requires_all_status_and_uncertainty_evidence',
'clock::tests::production_clock_stays_closed_until_native_adapter_qualification',
'clock::tests::suspend_closes_until_actual_post_resume_sync',
'clock::tests::timeout_worker_stays_closed_without_a_second_call',
'clock::tests::wall_step_and_overflow_fail_closed',
)
require = contract.require
def sha(path):
return hashlib.sha256(Path(path).read_bytes()).hexdigest()
def support_sources():
return {str(Path(module.__file__).resolve().relative_to(ROOT)): sha(module.__file__)
for module in (linux, contract, linux.access)}
def native_source_sha256():
return hashlib.sha256(inspect.getsource(native_case).encode()).hexdigest()
def save(folder, name, value):
fd = os.open(folder / name, os.O_CREAT | os.O_EXCL | os.O_WRONLY | os.O_NOFOLLOW, 0o600)
with os.fdopen(fd, 'w') as out:
json.dump(value, out, indent=2)
out.write('\n')
out.flush()
os.fsync(out.fileno())
def prepare():
require(sha(CASE / 'qualification.json') == QUALIFICATION_SHA, 'original build qualification')
qualified = contract.protected_json(CASE / 'qualification.json')
require(qualified['linux_clock_test_count'] == 5 and qualified['no_vm'] is True, 'five local portable guards only')
original = CASE / 'target/debug/deps/clock_midl_readiness-277aee462cb4f674'
raw = original.read_bytes()
require(raw[:6] == b'\x7fELF\x02\x01' and raw[18:20] == b'\x3e\x00', 'existing x64 Linux test executable')
os.umask(0o077)
STATE.mkdir(mode=0o700, parents=True, exist_ok=True)
folder = STATE / str(uuid.uuid4())
folder.mkdir(mode=0o700)
binary = folder / 'clock-portable-tests'
shutil.copyfile(original, binary)
binary.chmod(0o600)
require(sha(binary) == sha(original), 'byte-identical existing test executable')
for name, args in (
('elf', ['readelf', '--wide', '--program-headers', '--dynamic', '--version-info', str(binary)]),
('list', ['docker', 'run', '--rm', '--network', 'none', '--read-only', '-v', str(binary) + ':/tests:ro',
'--entrypoint', '/lib64/ld-linux-x86-64.so.2', qualified['image'], '/tests', '--list', '--format', 'terse']),
):
completed = subprocess.run(args, capture_output=True, timeout=15)
require(completed.returncode == 0, 'local loader/list metadata failed')
fd = os.open(folder / (name + '.log'), os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o600)
with os.fdopen(fd, 'wb') as out:
out.write(completed.stdout)
out.flush()
os.fsync(out.fileno())
listed = (folder / 'list.log').read_bytes()
require(set(re.findall(rb'^(.+): test$', listed, re.M)) == {name.encode() for name in TESTS}, 'exact existing five-test list')
info = (folder / 'elf.log').read_text()
needed = re.findall(r'\(NEEDED\).*?\[([^\]]+)\]', info)
glibc = sorted(set(re.findall(r'GLIBC_[0-9.]+', info)), key=lambda v: tuple(map(int, v[6:].split('.'))))
require('/lib64/ld-linux-x86-64.so.2' in info and needed and glibc, 'actual ELF loader dependencies')
manifest = dict(schema_version=1, type='rmm.clock.portable-unit-native-pack', original_build=str(CASE),
qualification_sha256=QUALIFICATION_SHA, runner_sha256=sha(__file__),
support_sources=support_sources(), native_case_sha256=native_source_sha256(),
artifact=dict(path=str(binary), bytes=binary.stat().st_size, sha256=sha(binary)),
original_test_executable=str(original), selected_tests=list(TESTS),
interpreter='/lib64/ld-linux-x86-64.so.2', needed=needed, maximum_glibc=glibc[-1],
list_sha256=sha(folder / 'list.log'), elf_sha256=sha(folder / 'elf.log'),
compiled_new_code=False, stripped=False, native_vm_executed=False,
linux_ndr_tested=False, windows_rpc_tested=False, product_clock_qualified=False)
save(folder, 'manifest.json', manifest)
print(json.dumps(dict(manifest=str(folder / 'manifest.json'), manifest_sha256=sha(folder / 'manifest.json'),
artifact=manifest['artifact'], interpreter=manifest['interpreter'], needed=needed,
maximum_glibc=glibc[-1], selected_tests=5, native_vm_executed=False)))
def verified(path):
manifest = contract.protected_json(path)
require(manifest['runner_sha256'] == sha(__file__) and manifest['selected_tests'] == list(TESTS), 'frozen native pack runner and exact tests')
require(manifest['support_sources'] == support_sources() and manifest['native_case_sha256'] == native_source_sha256(), 'frozen native transport/parser sources')
require(manifest['qualification_sha256'] == QUALIFICATION_SHA == sha(CASE / 'qualification.json'), 'actual original build')
require(manifest['compiled_new_code'] is False and manifest['stripped'] is False and manifest['native_vm_executed'] is False, 'existing portable harness only')
binary = Path(manifest['artifact']['path'])
require(sha(binary) == manifest['artifact']['sha256'] and binary.stat().st_size == manifest['artifact']['bytes']
and sha(manifest['original_test_executable']) == sha(binary), 'unchanged actual original Linux harness')
return manifest
def native_case(payload):
import resource
import stat
import time
root = Path('/var/lib/rmm-clock-midl-portable-tests')
ident = str(uuid.UUID(payload['id']))
names = [
'clock::tests::gate_requires_all_status_and_uncertainty_evidence',
'clock::tests::production_clock_stays_closed_until_native_adapter_qualification',
'clock::tests::suspend_closes_until_actual_post_resume_sync',
'clock::tests::timeout_worker_stays_closed_without_a_second_call',
'clock::tests::wall_step_and_overflow_fail_closed',
]
require(payload['id'] == ident and payload['action'] in ('prepare', 'run', 'read')
and payload['tests'] == names and os.geteuid() == 0, 'fixed exact portable test case')
digest = payload['binary_sha256']
require(len(digest) == 64 and all(c in '0123456789abcdef' for c in digest), 'fixed binary hash')
def safe(path, directory):
value = path.lstat()
require(value.st_uid == 0 and not value.st_mode & 0o077 and not stat.S_ISLNK(value.st_mode)
and (stat.S_ISDIR(value.st_mode) if directory else stat.S_ISREG(value.st_mode)), 'private fixed test path')
def write(path, value):
fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_WRONLY | os.O_NOFOLLOW, 0o600)
with os.fdopen(fd, 'w') as out:
json.dump(value, out)
out.flush()
os.fsync(out.fileno())
if payload['action'] == 'prepare' and not root.exists():
root.mkdir(mode=0o700)
safe(root, True)
case = root / ident
if payload['action'] == 'prepare':
case.mkdir(mode=0o700)
write(case / 'intent.json', payload)
return dict(prepared=True)
safe(case, True)
safe(case / 'intent.json', False)
intent = json.loads((case / 'intent.json').read_bytes())
require(all(intent[key] == payload[key] for key in ('id', 'binary_sha256', 'manifest_sha256', 'tests', 'runner_sha256', 'support_sources', 'native_case_sha256')), 'original create-once intent')
if payload['action'] == 'read':
safe(case / 'result.json', False)
return json.loads((case / 'result.json').read_bytes())
binary = case / 'clock-portable-tests'
safe(binary, False)
require(hashlib.sha256(binary.read_bytes()).hexdigest() == digest, 'actual staged original test bytes')
write(case / 'started.json', dict(binary_sha256=digest, tests=names, never_repeat_start=True))
binary.chmod(0o500)
temporary = case / 'tmp'
temporary.mkdir(mode=0o700)
env = {'PATH': '/usr/bin:/bin', 'LANG': 'C.UTF-8', 'TMPDIR': str(temporary), 'RUST_BACKTRACE': '0'}
namespace = subprocess.run(['/usr/bin/unshare', '--net', '--', '/usr/bin/true'], env=env, capture_output=True, timeout=3)
require(namespace.returncode == 0, 'network namespace required; no fallback')
loader = subprocess.run(['/lib64/ld-linux-x86-64.so.2', '--list', str(binary)], env=env, capture_output=True, timeout=3)
require(loader.returncode == 0 and len(loader.stdout) <= 16384 and len(loader.stderr) <= 16384, 'actual native loader compatibility')
def limits():
resource.setrlimit(resource.RLIMIT_CORE, (0, 0))
resource.setrlimit(resource.RLIMIT_FSIZE, (1048576, 1048576))
resource.setrlimit(resource.RLIMIT_CPU, (10, 10))
results = []
deadline = time.monotonic() + 20
for number, name in enumerate(names):
output = case / (str(number) + '-stdout.bin')
errors = case / (str(number) + '-stderr.bin')
timed_out = False
with output.open('xb') as stdout, errors.open('xb') as stderr:
output.chmod(0o600)
errors.chmod(0o600)
try:
remaining = deadline - time.monotonic()
require(remaining > 0, 'aggregate test deadline')
child = subprocess.run(['/usr/bin/unshare', '--net', '--', str(binary), '--exact', name, '--test-threads=1'],
cwd=case, env=env, stdin=subprocess.DEVNULL, stdout=stdout, stderr=stderr,
timeout=min(5, remaining), preexec_fn=limits)
code = child.returncode
except subprocess.TimeoutExpired:
timed_out = True
code = None
stdout.flush()
stderr.flush()
os.fsync(stdout.fileno())
os.fsync(stderr.fileno())
raw, err = output.read_bytes(), errors.read_bytes()
require(len(raw) <= 1048576 and len(err) <= 1048576, 'bounded unit output')
results.append(dict(name=name, exit_code=code, timed_out=timed_out, stdout_b64=base64.b64encode(raw).decode(), stderr_b64=base64.b64encode(err).decode()))
if code != 0:
break
report = dict(id=ident, binary_sha256=digest, manifest_sha256=payload['manifest_sha256'], results=results,
native_platform='linux', network_namespace=True, environment_cleared=True,
loader_stdout_sha256=hashlib.sha256(loader.stdout).hexdigest(), linux_ndr_tested=False,
windows_rpc_tested=False, product_clock_qualified=False, rmm_jobs_created=False)
write(case / 'result.json', report)
return report
def native(path, access_root, ident=None):
manifest = verified(path)
linux.ROOT = linux.access.ROOT = access_root.resolve()
os.umask(0o077)
if ident is None:
ident = str(uuid.uuid4())
folder = STATE / ident
folder.mkdir(mode=0o700)
payload = dict(id=ident, binary_sha256=manifest['artifact']['sha256'], manifest_sha256=sha(path), tests=list(TESTS),
runner_sha256=manifest['runner_sha256'], support_sources=manifest['support_sources'], native_case_sha256=manifest['native_case_sha256'])
save(folder, 'intent.json', dict(payload=payload, manifest_path=str(path.resolve())))
linux.rpc('linux-vm.conf', native_case, dict(payload, action='prepare'))
cfg = linux.access.load_config(access_root / 'credentials/linux-vm.conf')
args = ['sftp', '-F', '/dev/null', '-P', cfg.get('port', '22'), '-o', 'StrictHostKeyChecking=yes', '-o', 'BatchMode=yes',
'-o', 'IdentitiesOnly=yes', '-o', 'ForwardAgent=no', '-o', 'ConnectTimeout=10', '-i', str(Path(cfg['ssh_key_path']).expanduser()),
'-b', '-', cfg['username'] + '@' + cfg['address']]
result = subprocess.run(args, input=('put ' + json.dumps(manifest['artifact']['path']) + ' ' + json.dumps(REMOTE + '/' + ident + '/clock-portable-tests') + '\n').encode(), capture_output=True, timeout=120)
save(folder, 'upload.json', dict(returncode=result.returncode))
require(result.returncode == 0, 'fixed portable binary upload')
save(folder, 'run-intent.json', dict(execute_only_exact_five_portable_units=True))
value = linux.rpc('linux-vm.conf', native_case, dict(payload, action='run'))
else:
ident = str(uuid.UUID(ident))
folder = STATE / ident
intent = contract.protected_json(folder / 'intent.json')
payload = intent['payload']
require(intent['manifest_path'] == str(path.resolve()) and payload['manifest_sha256'] == sha(path), 'original same native case')
require(payload['runner_sha256'] == manifest['runner_sha256'] and payload['support_sources'] == manifest['support_sources']
and payload['native_case_sha256'] == manifest['native_case_sha256'], 'original same native sources')
value = linux.rpc('linux-vm.conf', native_case, dict(payload, action='read'))
save(folder, 'readback-' + str(uuid.uuid4()) + '.json', value)
require(value['binary_sha256'] == manifest['artifact']['sha256'] and value['manifest_sha256'] == sha(path)
and len(value['results']) == 5 and value['product_clock_qualified'] is False, 'all five exact portable results')
for result, name in zip(value['results'], TESTS, strict=True):
require(result['name'] == name and result['exit_code'] == 0 and result['timed_out'] is False
and b'1 passed; 0 failed; 0 ignored;' in base64.b64decode(result['stdout_b64'], validate=True), 'one exact native portable unit passed')
proof = dict(verified=True, case_id=ident, native_platform='linux', selected_tests=5, manifest_sha256=sha(path), report=value)
if (folder / 'passed.json').exists():
require(contract.protected_json(folder / 'passed.json') == proof, 'unchanged original native proof')
else:
save(folder, 'passed.json', proof)
print(json.dumps(dict(verified=True, case_id=ident, selected_native_portable_tests=5, linux_ndr_tested=False, product_clock_qualified=False)))
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('action', choices=('prepare-local', 'native', 'readback'))
parser.add_argument('--manifest', type=Path)
parser.add_argument('--access-root', type=Path)
parser.add_argument('--case')
parser.add_argument('--execute-native-tests', action='store_true')
args = parser.parse_args()
if args.action == 'prepare-local':
require(not (args.manifest or args.access_root or args.case or args.execute_native_tests), 'local packaging only')
prepare()
elif args.action == 'native':
require(args.manifest and args.access_root and args.execute_native_tests and not args.case, 'Root explicitly starts one fixed native case')
native(args.manifest, args.access_root)
else:
require(args.manifest and args.access_root and args.case and not args.execute_native_tests, 'same-case readback only')
native(args.manifest, args.access_root, args.case)
if __name__ == '__main__':
main()
+237
View File
@@ -0,0 +1,237 @@
# Getrennter Diagnosebuild mit tatsächlichem Microsoft-MIDL-Output
Stand 2026-11-14. Eigene Buildquelle; keine Änderung des Produktbuilders,
der bisherigen Runner oder früherer Binär-/Abnahmebelege. Kein VM-Zugriff,
kein RMM-Job und keine Clockqualifikation durch diesen lokalen Build.
## Tatsächliche Eingangsdaten
Root hat MIDL auf der Windows-VM im eigenen Fall
`149bafe2-3469-4580-b133-988812bcc3db` ausgeführt und anschließend denselben
Fall separat nur gelesen. Der neue lokale Builder prüft dessen vollständigen
Readback gegen SHA256
`0dc2373825f7f8f224cda04ecd5c521dd3c37a6e712bc3ed83bc4fa6d0d89c8c`.
Der Beleg enthält erfolgreiche Microsoft-Authenticode-/Kettenprüfung der
festen Tools, Codegenexit0 und das Ende aller eigenen Prozesse. Es fand kein
RPC-Aufruf statt; `clock_qualified=false` bleibt ausdrücklich erhalten.
Die zwei zurückgelesenen tatsächlichen Outputs werden unverändert als neue
Buildinputs kopiert und sowohl gegen die Originalbytes im Readback als auch
gegen feste Hashes geprüft:
| Datei | Bytes | SHA256 |
|---|---:|---|
| `w32time.h` | 3779 | `db5dbe5b335eaa58a6512d4abfda44e7273f3aa8a43077dcb0719e4b97ee2bde` |
| `w32time_c.c` | 18866 | `d806adb431f16724c8afdea0c0751588a4bc6f82b6f0b8391d4d189d6a6f4a38` |
`deploy/windows/clock_midl_diagnostic_build.py` erstellt pro lokalem Aufruf einen
neuen privaten Fall unter `devstate/windows-clock-midl/diagnostic-builds/`.
Er kopiert einen gehashten Quellsnapshot und verwendet ausschließlich diesen
Snapshot. Das separate Cargo-Paket unter
`deploy/windows/clock-midl-diagnostic/` bindet das vorhandene originale
`examples/clock_readiness.rs` und dessen originales `src/clock.rs` ein. C-Wrapper,
Endpointcode und Narrow-IDL sind ebenfalls unverändert und im neuen build.rs
zusätzlich fest gepinnt. `ADAPTER_QUALIFIED=false`, Authentisierung, Statusguard,
SEH- und Allocatorgrenzen werden nicht verändert.
Es wird weder ein Compilerwrapper anstelle von WIDL ausgegeben noch ein
bestehendes OUT_DIR nachträglich verändert. Das neue build.rs kompiliert die
zuvor geprüften Originaloutputs direkt, ohne Generatorfallback oder NDR-Patch.
Der vorhandene Produktpfad `crates/agent-windows/build.rs` bleibt unverändert.
Der Lockfileabgleich erlaubt keine neue externe Paketversion gegenüber dem
ursprünglichen Root-Lockfile. Alle nachfolgenden Cargobefehle verwenden
`--locked --offline`; Docker läuft ohne Netzwerk und mit read-only Rootfilesystem.
## Tatsächliche Compiler-/Linkerbefunde
Die Microsoft-Quelldatei schützt ihren AMD64-Code mit `_M_AMD64`; Clang/GNU
definiert diesen Makronamen nicht selbst. Nur im getrennten tatsächlichen
x64-Build wird deshalb `_M_AMD64=100` gesetzt. Weder `_MSC_VER` noch
`__RPCNDR_H_VERSION__` werden definiert oder erhöht. Der echte MinGW-Header
meldet475; der originale Microsoft-Header verlangt475.
Der unveränderte Microsoftstub enthält legale C-Klammerelision an einem
Unioninitializer sowie zwei unbenutzte konstante Tabellen. Der erste strikte
Versuch scheiterte an `-Wmissing-braces`; der zweite bewahrte zusätzlich die
konkreten `-Wunused-const-variable`-Befunde. Nur die exakt gepinnte generierte
Stubunit erhält `-Wno-error=missing-braces` und
`-Wno-error=unused-const-variable`: Die drei Warnungen bleiben im Log sichtbar,
alle übrigen Diagnosen bleiben Fehler. Die beiden unveränderten C-Wrapper
werden getrennt weiterhin mit `-Wall -Wextra -Werror` kompiliert. Kein
Typfehler, Strukturassert oder Sicherheitscheck wird abgeschaltet.
Das isolierte kleine Rustpaket benötigt außerdem `mincore` zum Linken der
beiden unveränderten präzisen Interruptzeitgetter. Das vorhandene
MinGW-Kernel32-Importarchiv kennt sie nicht; `libmincore.a` enthält die
Windows-Realtime-API-Imports. Bereits die vorherige Readiness-EXE91889303…
importierte beide Getter über `api-ms-win-core-realtime-l1-1-1.dll`.
Es gibt keinen Ersatzgetter, keine Zeitberechnung aus Serverzeit und keinen
Runtimefallback. Die neuen PE-Imports werden separat erhalten.
Der tatsächlich erfolgreiche neue Link wählt für diese beiden Getter
`api-ms-win-core-realtime-l1-1-2.dll`, der frühere918…-Link dagegen
`api-ms-win-core-realtime-l1-1-1.dll`. Das ist eine zusätzliche tatsächliche
Linkdifferenz, kein reiner Einvariablenvergleich ausschließlich des Generators.
Ihre native Zulässigkeit wird hier nicht behauptet.
Die unvollständigen Fälle `4ce00b43-4ca1-4e50-9f65-e89bd82f9364`,
`81b5503a-d78f-49be-b323-380c254cedff` und
`81d93ea1-f886-4853-8db4-f4e1c95f33ea` bleiben samt Eingängen und Logs erhalten.
Der letzte enthält bereits erfolgreiche Windows-Clippy- und fünf tatsächliche
Linux-Clocktests, aber einen fehlgeschlagenen Windows-Testlink. Diese Fälle
sind keine erfolgreichen vollständigen Diagnosebuilds.
## Ausführung und Nachweisgrenzen
Lokaler Buildbefehl, keine VM-Aktion:
```text
python3 deploy/windows/clock_midl_diagnostic_build.py
```
Jeder Fall erhält Intent, genaue Compiler-/Lock-/Quellhashes und einzelne
Checklogs. Nur nach erfolgreichen fünf tatsächlichen Clocktests, Windows-
Clippy/-Testlink und Release-Link wird eine finale Qualifikation geschrieben.
Original-Linkdatei und separat gestrippte `WindowsClockReadiness.exe` bleiben
beide erhalten. Ein Windows-Crosslink ist kein nativer Windows-Lauf.
Vollständiger tatsächlich erfolgreicher Fall:
`181c3a1c-8324-41fd-9b7c-aa8010262912`.131Compilerinputs vor/nach identisch;
Fmt, Windows-Alltargets-Clippy mit Rust-Warnungen als Fehler, alle fünf
Linux-Clocktests ohne Skip, Windows-Unitlink, Release-Link und PE-Importausgabe
bestanden. Die sichtbaren drei C-Stilwarnungen gelten ausschließlich für die
oben beschriebene gepinnte Microsoftstubunit.
- Finale EXE:1217536Bytes, SHA256
`b1d3da4f393ddf20bc8e48a9894ee314666f2ac3613ef97f5c228e3d089ca560`.
- Original-Linkdatei SHA256:
`5efcbbbdfe9c9d8b5954e4d550ba8f35fbaf1bcffefa610bd25b0c3797340d1c`.
- Finale `qualification.json` SHA256:
`2e0de3acf72ab5c3a8e0baa54e8643d086ea7c03d1b38fd89b6bfc00e45f8cbb`.
Python-Syntaxprüfung des neuen Builders wurde ebenfalls tatsächlich ausgeführt.
Das ist lokale Crossbuild-/Vertragsqualifikation, kein Cloud-Linux- oder
Windows-VM-Nachweis und kein bestätigter Fix für die bisherige RPC1783-Ausnahme.
Eine spätere tatsächliche Ausführung bleibt eine eigene Root-geführte
Diagnose mit konkretem Binaryhash und dem bestehenden Readinessrunner.
Selbst ein erfolgreicher Statusreturn würde weder die Named-Pipe-Serveridentität
noch Clockauthority oder den SYSTEM-/Jobpfad qualifizieren. Keine automatische
Wiederholung früherer RPC-Aufrufe und keine Genehmigungsabkürzung.
## Ursprüngliche Vorbereitung der portablen Linux-Vorstufe
`deploy/windows/clock_midl_linux_native.py prepare-local` wurde tatsächlich
lokal ausgeführt. Es kopiert ausschließlich die bereits im erfolgreichen
Build181c… ausgeführte Linux-Testexe; kein neuer Build und kein Strip.
Der separate Packfall lautet `f5d85873-96b2-41d5-97be-4c8f5c6baaef`, unter
`devstate/windows-clock-midl/linux-native-packs/`. Finale Manifest-SHA256:
`dcd6351898a1893253b352dce144d52dd45cd71aa1453295e648aa9d41afa67c`.
Die tatsächlichen unveränderten26577504Bytes besitzen SHA256
`6b3153d0d781798454f483c1c5b58089dcd2fe98b03c43aea3d928fd6107a9c8`.
ELF-Metadaten: x86-64, Interpreter `/lib64/ld-linux-x86-64.so.2`, höchste
benötigte Version `GLIBC_2.34`, direkte Abhängigkeiten `libc.so.6`,
`ld-linux-x86-64.so.2`, `libgcc_s.so.1`. Containerseitiges reines Listing
derselben Bytes bestätigt genau diese fünf bereits bestehenden Tests:
```text
clock::tests::gate_requires_all_status_and_uncertainty_evidence
clock::tests::production_clock_stays_closed_until_native_adapter_qualification
clock::tests::suspend_closes_until_actual_post_resume_sync
clock::tests::timeout_worker_stays_closed_without_a_second_call
clock::tests::wall_step_and_overflow_fail_closed
```
Der neue Runner besitzt die getrennten Aktionen `native` und `readback`.
Nur Root führt `native --execute-native-tests --access-root <Hauptrepo>
--manifest <dieser lokale Manifestpfad>` aus. Der bestehende strikte
SSH-/Credentialparser wird ausschließlich dann aufgerufen. Der Zielpfad
`/var/lib/rmm-clock-midl-portable-tests/<neue UUID>` ist privat und create-only.
Originalintent, Startmarker vor dem ersten Prozess und finales Ergebnis werden
dauerhaft gespeichert. Verlorene Antwort erlaubt nur `readback --case <dieselbe
UUID>`; kein zweiter Start. Ausschließlich die fünf hart codierten Tests dürfen
laufen, mit eigener Netzwerknamespace, bereinigter Umgebung, fünf Sekunden
je Test, zwanzig Sekunden Gesamtbudget und begrenzter Ausgabe. ELF-Loaderprüfung
erfolgt zusätzlich auf dem tatsächlichen Linuxziel. Keine bestehenden Dienste,
Jobs, Journale, Policies, Schlüssel oder Zeitdienstkonfiguration werden benutzt.
Python-Syntax und lokales ELF-/Listpaket sind geprüft. **Der Autor dieses
Quellschnitts hat keine VM-Verbindung oder native Testausführung vorgenommen.**
Ein späterer Linux5/5-Beleg betrifft ausschließlich portable Clockguards,
keine Linux-NDR-Prüfung und keinerlei Windows-RPC-/Serveridentitäts- oder
Clockauthority-Nachweis. Root führt Windowsdiagnostik getrennt danach aus.
### Readbackkorrektur vor der ersten nativen Ausführung
Root-Review fand im zuvor vorbereiteten Linuxrunner einen konkreten Fehler:
Auch `read` hätte bei fehlender Zielwurzel ein Verzeichnis angelegt. Die
Korrektur beschränkt diese einzige Wurzelanlage auf `prepare`; `read` und
`run` verweigern eine fehlende Wurzel ausschließlich lesend. Der äußere
Readbackzweig ruft nur `action=read` auf, ohne Prepare, Upload oder Teststart.
Das ursprüngliche Pack f5d85873… bleibt erhalten, ist durch seinen alten
Runnerhash aber für den korrigierten Runner nicht mehr verwendbar.
Der neue Packfall **68c5b69c-3391-4ff9-943d-3e5955be4e1f** enthält dieselben
unveränderten Testexebytes und dieselbe ursprüngliche Buildqualifikation.
Neues `manifest.json` SHA256:
`eceec2cc3f778cc46d58d1c10679fc38e5fcc7c7bee6eac99ef9454162f7ce48`.
Runner-SHA256:
`27a6a62e24a3908765bfe3c94d5ae75022210ebc6ab35ffc7f659bfe45844956`.
Die tatsächliche `native_case`-Teilquelle ist zusätzlich separat mit SHA256
`ab7cd86e03684a6e7167d0c6814bc71edb39046e07b5794cfb0d6f195e2b6828`
gebunden. Manifest und spätere Originalintents binden außerdem die drei
Supportquellen `remote_client_bootstrap.py`, `vm_mvp_acceptance.py` und
`vm_access_check.py`. Jeder Native-/Readbackaufruf prüft diese Bindungen vor
dem ersten SSH-Aufruf; Sourceänderung verweigert den Zugriff.
Tatsächlich lokal mit gemockten Ziel-/Transportobjekten geprüft: `read` bei
fehlender Wurzel ohne mkdir/open/Prozessstart; gleiches für `run`; äußerer
Readback genau ein Read-RPC ohne mkdir/SFTP/Testlauf; geänderte Supporthashes
vor RPC verweigert. Vier Guards bestanden, kein realer Zielzugriff. Beleg:
`readback-guards.json` im neuen Pack, SHA256
`4db073802235d86b5233255a5fbf42be87808307abe32f47c4f6bb059ae8de31`.
Python-Syntax und erneutes reines ELF-/Testlisting bestanden. Alle ursprünglichen
131 Windowsbuildinputs wurden erneut gegen181c… verglichen und sind exakt
unverändert. Kein neuer Build, kein Strip und keine native Ausführung.
## Danach tatsächlich: Cloud-Linux5 und Windowsdiagnose
Root führte den korrigierten Pack68c5b69c nativ auf der Cloud-Linux-Test-VM
aus. Fall `222a0d60-4ddb-41c3-961c-2fa04138db28`: alle fünf festen portablen
Clocktests bestanden, jeder als exakter eigener Fall, keine ignorierten Fälle.
Originalbytes/Loader, Netzwerknamespace, begrenzte Ausgabe und feste Budgets
geprüft. `passed.json`-SHA256:
`b045ddccba9fff80ecba3b81649e14330b58f79b04990b5b257b1d6a3df39d3e`.
Keine Linux-NDR- oder Windows-RPC-Prüfung aus diesem Erfolg ableiten.
Erst danach wurde Windows-EXEb1d3da4f im neuen eigenen LocalService-
Diagnosefall `94562d81-f75f-45c8-ab6b-28b70d12bd81` einmal ausgeführt.
Der bestehende Readinessrunner blieb unverändert; anschließend wurde derselbe
Originalbericht separat nur lesend identisch bestätigt. Der eigene temporäre
Dienst wurde entfernt. ResultatSHA256:
`91176b2c6832573786de9a8a15f9f239a0f93d7b0d5fef5eb36ac39f992b9232`.
Tatsächliches Token: SID19/LocalService, kein Administrator und kein SYSTEM.
Beide ALPC-Versuche sowie deren falsche Account-/Servicekontrollen liefern
weiter1753 ohne Status; damit ist keine Identitätsverweigerung bewiesen.
Die getrennte Named-Pipe-Diagnose liefert jetzt **RPC5/AccessDenied** statt
des früheren1783. Trace: Stage90, `rpc_exception=5`, kein normaler nativer
Return und kein Status. Dies ist eine neue konkrete Fehlerbeobachtung,
**keine erfolgreiche W32Time-Abfrage** und kein isolierter Ursachennachweis;
die dokumentierte APIset-Linkdifferenz bleibt Bestandteil dieses Kandidaten.
Ein separater Vorher-/Nachherabgleich des tatsächlich laufenden Agent-/
Helperpaars prüfte PIDs/Geburt, Dateien/PKI/DB-/Lock-Datei-IDs, Helperwitness und
geschlossene Serverzähler/Flags unverändert. NachherbelegSHA256:
`09493104ca46b53b235df677f70289ef48bbfd718c8f5c82790921986db27bc8`.
Keine W32Time-ACL-/Konto-/NTP-Änderung, kein Agentwechsel oder RMM-Job.
Microsoft dokumentiert für LocalService anonyme Netzwerkanmeldedaten und für
MS-W32T den authentisierten Named-Pipe-Endpunkt W32TIME_ALT.
[LocalService](https://learn.microsoft.com/en-us/windows/win32/services/localservice-account),
[MS-W32T-Transport](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-w32t/e0803f6b-e175-4b87-ba63-bbcf51175655).
Ein Token-/Authentisierungseinfluss ist damit eine begründete **Hypothese**,
keine bewiesene Ursache des konkreten5. Als nächster enger Diagnoseschritt wird
ein eigener lesender SYSTEM-Vergleich mit unveränderten C-/Auth-/MIDLinputs
vorbereitet; kein Lockern der bestehenden LocalService-Prüfung oder
Zeitdienstrechte. Produktgate/Clock/Jobs bleiben geschlossen.