test: qualify MIDL diagnostic build and record native access denial
Rust development slice / linux (push) Failing after 7s
Rust development slice / linux (push) Failing after 7s
This commit is contained in:
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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.
|
||||
Reference in New Issue
Block a user