Document native Windows EEInfo probe and preserved closed gates
Rust development slice / linux (push) Failing after 6s

This commit is contained in:
2026-11-14 17:36:50 +01:00
parent 19f0b1e7f6
commit 29e35c4fb6
6 changed files with 1080 additions and 0 deletions
+138
View File
@@ -0,0 +1,138 @@
#!/usr/bin/env python3
"""Local-only SYSTEM trace diagnostic build; no VM and no product source edits."""
import base64
import difflib
import hashlib
import importlib.util
import json
import os
from pathlib import Path
import re
import shutil
import subprocess
import uuid
ROOT = Path(__file__).resolve().parents[3]
HERE = Path(__file__).resolve().parent
STATE = ROOT / 'devstate/windows-clock-eeinfo-trace'
IMAGE = 'sha256:1b2fd985d2c1fcc3545ace602405dc68fa899201bd8a73fa319ff96377203fa9'
BASELINE = ROOT / 'devstate/windows-clock-midl/diagnostic-builds/181c3a1c-8324-41fd-9b7c-aa8010262912/qualification.json'
BASELINE_SHA = '2e0de3acf72ab5c3a8e0baa54e8643d086ea7c03d1b38fd89b6bfc00e45f8cbb'
NATIVE = ROOT / 'devstate/windows-clock-midl/native-cases/149bafe2-3469-4580-b133-988812bcc3db'
READBACK = NATIVE / 'readback-059c15ef-0f31-41aa-ad1d-ea6b774280d7.json'
READBACK_SHA = '0dc2373825f7f8f224cda04ecd5c521dd3c37a6e712bc3ed83bc4fa6d0d89c8c'
def require(value, message):
if not value: raise RuntimeError(message)
def sha(path):
return hashlib.sha256(Path(path).read_bytes()).hexdigest()
def write(path, raw):
path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_WRONLY | os.O_NOFOLLOW, 0o600)
with os.fdopen(fd, 'wb') as output:
output.write(raw); output.flush(); os.fsync(output.fileno())
def save(path, value):
write(path, (json.dumps(value, indent=2) + '\n').encode())
def original_sources():
require(sha(BASELINE) == BASELINE_SHA, 'original b1d3 qualification')
value = json.loads(BASELINE.read_bytes())
require(len(value['source_files']) == 131 and value['artifact']['sha256'] == 'b1d3da4f393ddf20bc8e48a9894ee314666f2ac3613ef97f5c228e3d089ca560', 'unchanged complete original131 source set')
for name, digest in value['source_files'].items():
path = ROOT / name
require(not path.is_symlink() and path.is_file() and sha(path) == digest, 'original131 input changed')
return value
def own_sources():
return {str((HERE / name).relative_to(ROOT)):sha(HERE / name) for name in ('clock_rpc_eeinfo.c','system_trace_eeinfo.c','build.py','native.py')}
def main():
os.umask(0o077)
baseline = original_sources(); before = own_sources()
require(sha(READBACK) == READBACK_SHA, 'actual Microsoft codegen readback')
receipt = json.loads(READBACK.read_bytes())
require(receipt['readback_only'] is True and receipt['result']['complete'] is True
and receipt['result']['run']['exit_code'] == 0 and receipt['result']['no_rpc'] is True,
'actual completed MIDL codegen')
folder = STATE / ('build-' + str(uuid.uuid4())); folder.mkdir(mode=0o700, parents=True)
source = folder / 'source'; source.mkdir(mode=0o700)
generated = {}
for name, digest in baseline['generated_inputs'].items():
path = NATIVE / ('native-' + name); raw = path.read_bytes()
item = next(item for item in receipt['files'] if item['name'] == name)
require(sha(path) == item['sha256'] == digest and len(raw) == item['bytes']
and base64.b64decode(item['base64'], validate=True) == raw, 'same actual unchanged Microsoft output')
write(source / name, raw); generated[name] = digest
baseline_wrapper = ROOT / 'crates/agent-windows/native/clock_rpc.c'
require(sha(baseline_wrapper) == '74aceb6e2b70c5dd628fae069a842c356c20300b8c8ab12754258c78eaf295c8','same original C/Auth wrapper')
wrapper = HERE / 'clock_rpc_eeinfo.c'
write(source / 'clock_rpc.c', wrapper.read_bytes()); write(source / 'system_trace.c', (HERE / 'system_trace_eeinfo.c').read_bytes())
delta = ''.join(difflib.unified_diff(baseline_wrapper.read_text().splitlines(True),wrapper.read_text().splitlines(True),fromfile='original-clock_rpc.c',tofile='diagnostic-clock_rpc_eeinfo.c'))
write(folder / 'wrapper-source.diff',delta.encode())
save(folder / 'intent.json', dict(image=IMAGE, original131=baseline['source_files'], baseline_sha256=BASELINE_SHA,
actual_codegen_readback_sha256=READBACK_SHA, generated=generated, own_sources=before,
wrapper_sha256=sha(wrapper), original_wrapper_sha256=sha(baseline_wrapper), wrapper_diff_sha256=sha(folder / 'wrapper-source.diff'), own_system_token_only=True, exactly_one_trace_call=True, no_vm=True))
output = folder / 'output'; output.mkdir(mode=0o700)
checks = {}
def run(name, args):
command = ['docker','run','--rm','--network','none','--read-only','--tmpfs','/tmp:rw,size=128m',
'-v',str(source)+':/src:ro','-v',str(output)+':/out','--entrypoint',args[0],IMAGE,*args[1:]]
done = subprocess.run(command,capture_output=True,timeout=120)
write(folder / (name+'.stdout'),done.stdout); write(folder / (name+'.stderr'),done.stderr)
checks[name] = dict(exit_code=done.returncode,command=command,stdout_sha256=sha(folder / (name+'.stdout')),stderr_sha256=sha(folder / (name+'.stderr')))
save(folder / (name+'.json'),checks[name]); require(done.returncode == 0,'local diagnostic compile/check failure: '+name)
return done.stdout
flags = ['--target=x86_64-w64-windows-gnu','-fms-extensions','-Wall','-Wextra','-Werror','-D_M_AMD64=100','-I/src','-O2']
run('main',['clang',*flags,'-c','/src/system_trace.c','-o','/out/system_trace.o'])
run('wrapper',['clang',*flags,'-c','/src/clock_rpc.c','-o','/out/clock_rpc.o'])
run('actual-midl',['clang',*flags,'-Wno-error=missing-braces','-Wno-error=unused-const-variable','-c','/src/w32time_c.c','-o','/out/w32time_c.o'])
run('link',['x86_64-w64-mingw32-gcc','-static-libgcc','-municode','/out/system_trace.o','/out/clock_rpc.o','/out/w32time_c.o',
'-lrpcrt4','-ladvapi32','-lkernel32','-lmincore','-o','/out/ClockSystemEeInfoTrace.linked.exe'])
raw_linked = output / 'ClockSystemEeInfoTrace.linked.exe'
linked = output / 'ClockSystemEeInfoTrace.original.exe'; delivery = output / 'ClockSystemEeInfoTrace.exe'
# Retain a caller-owned private exact copy; Docker's root-owned raw link is
# kept too. No chmod/chown of unrelated objects or source mutation.
shutil.copyfile(raw_linked,linked); linked.chmod(0o600)
shutil.copyfile(linked,delivery); delivery.chmod(0o600)
run('strip',['x86_64-w64-mingw32-strip','--strip-debug','/out/ClockSystemEeInfoTrace.exe'])
imports = sorted(set(re.findall(r'DLL Name:\s+(\S+)',run('imports',['x86_64-w64-mingw32-objdump','-p','/out/ClockSystemEeInfoTrace.exe']).decode())))
require(imports and {name.lower() for name in imports}.issubset({'kernel32.dll','msvcrt.dll','advapi32.dll','rpcrt4.dll','api-ms-win-core-realtime-l1-1-2.dll'}),'reviewed system DLL imports only')
data = delivery.read_bytes(); offset = int.from_bytes(data[60:64],'little')
require(data[:2] == b'MZ' and data[offset:offset+6] == b'PE\0\0\x64\x86' and len(data) < 1048576,'bounded standalone C x64 PE')
spec = importlib.util.spec_from_file_location('system_trace_native',HERE / 'native.py'); native = importlib.util.module_from_spec(spec); spec.loader.exec_module(native)
script = folder / 'native.ps1'; write(script,native.SCRIPT.encode())
parser = "$e=$null;$t=$null;[System.Management.Automation.Language.Parser]::ParseFile($args[0],[ref]$t,[ref]$e)|Out-Null;if($e.Count){$e|ForEach-Object{$_.Message};exit 1};'AST_PASS'"
parser_path = folder / 'parse-native.ps1'; write(parser_path,parser.encode())
parsed = subprocess.run(['/tmp/rmm-powershell-parser/pwsh','-NoLogo','-NoProfile','-NonInteractive','-File',str(parser_path),str(script)],capture_output=True,timeout=15)
write(folder / 'powershell-parser.stdout',parsed.stdout); write(folder / 'powershell-parser.stderr',parsed.stderr)
require(parsed.returncode == 0 and b'AST_PASS' in parsed.stdout and not parsed.stderr,'actual PowerShell AST')
command_chars = len(native.encoded_command())
require(command_chars < 32767,'Windows encoded command length')
require(original_sources()['source_files'] == baseline['source_files'] and own_sources() == before,'all original131 and new sources unchanged')
manifest = dict(schema_version=1,profile='clock-system-eeinfo-v1',image=IMAGE,baseline_sha256=BASELINE_SHA,
original131=baseline['source_files'],own_sources=before,wrapper_sha256=sha(wrapper),original_wrapper_sha256=sha(baseline_wrapper),wrapper_diff_sha256=sha(folder / 'wrapper-source.diff'),generated=generated,
actual_codegen_readback_sha256=READBACK_SHA,checks=checks,script_sha256=hashlib.sha256(native.SCRIPT.encode()).hexdigest(),
powershell_ast_passed=True,encoded_command_characters=command_chars,
artifact=dict(path=str(delivery),sha256=sha(delivery),bytes=len(data),imports=imports),
linked=dict(path=str(linked),sha256=sha(linked)),raw_linked_sha256=sha(raw_linked),native_executed=False,clock_qualified=False,
adapter_qualified=False,product_gate_open=False,no_vm=True,no_rmm_jobs=True)
save(folder / 'manifest.json',manifest)
print(json.dumps(dict(manifest=str(folder / 'manifest.json'),manifest_sha256=sha(folder / 'manifest.json'),artifact=manifest['artifact'],
original131_unchanged=True,powershell_ast=True,command_characters=command_chars,native_executed=False)))
if __name__ == '__main__':
try: main()
except Exception as error:
print(json.dumps(dict(error='CLOCK_SYSTEM_TRACE_LOCAL_INCOMPLETE',error_class=type(error).__name__,details_suppressed=True)))
raise SystemExit(2) from None
@@ -0,0 +1,291 @@
/* Only the authenticated local MS-W32T status operation is reachable here.
* NDR code is generated by WIDL; SEH must terminate inside C, never in Rust.
*/
#define _WIN32_WINNT 0x0a00
#include <windows.h>
#include <rpc.h>
#include <rpcasync.h>
#include <stdint.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include "w32time.h"
/* Documented public SDK API; older MinGW headers omit its declaration. */
int RPC_ENTRY RpcExceptionFilter(unsigned long exception_code);
/* Older MinGW headers stop at V3. This is the documented x64 V5 SDK layout,
* not a fallback to an older authentication contract. MSVC also checks it
* directly against its native SDK declaration. Windows x64 is the only target.
* https://learn.microsoft.com/windows/win32/api/rpcdce/ns-rpcdce-rpc_security_qos_v5_w
*/
typedef struct {
unsigned long Version, Capabilities, IdentityTracking, ImpersonationType;
unsigned long AdditionalSecurityInfoType;
union { RPC_HTTP_TRANSPORT_CREDENTIALS_W *HttpCredentials; } u;
void *Sid;
unsigned int EffectiveOnly;
void *ServerSecurityDescriptor;
} RmmRpcQosV5;
_Static_assert(sizeof(RmmRpcQosV5) == 56, "x64 RPC QOS V5 ABI");
_Static_assert(offsetof(RmmRpcQosV5, Sid) == offsetof(RPC_SECURITY_QOS_V3_W, Sid), "SDK QOS prefix ABI");
_Static_assert(offsetof(RmmRpcQosV5, ServerSecurityDescriptor) == 48, "x64 server descriptor ABI");
#ifdef _MSC_VER
_Static_assert(sizeof(RmmRpcQosV5) == sizeof(RPC_SECURITY_QOS_V5_W), "native SDK QOS V5 ABI");
_Static_assert(offsetof(RmmRpcQosV5, ServerSecurityDescriptor) == offsetof(RPC_SECURITY_QOS_V5_W, ServerSecurityDescriptor), "native SDK descriptor ABI");
#endif
typedef struct Allocation { struct Allocation *next; size_t size; } Allocation;
typedef struct { Allocation *head; size_t total; } Arena;
/* Explicit Windows TLS also works on threads created by SCM. Clang static TLS
* in the mixed Rust/MinGW PE did not initialize such a thread's storage. */
static INIT_ONCE arena_once = INIT_ONCE_STATIC_INIT;
static DWORD arena_index = TLS_OUT_OF_INDEXES;
static BOOL CALLBACK initialize_arena(PINIT_ONCE once, PVOID parameter, PVOID *context) {
(void)once; (void)parameter; (void)context;
arena_index = TlsAlloc();
return arena_index != TLS_OUT_OF_INDEXES;
}
void *__RPC_USER MIDL_user_allocate(size_t size) {
Arena *arena = TlsGetValue(arena_index);
if (!arena || size > 65536 || arena->total > 65536 - size) return NULL;
Allocation *p = calloc(1, sizeof(*p) + size);
if (!p) return NULL;
p->size = size; p->next = arena->head; arena->head = p; arena->total += size;
return p + 1;
}
void __RPC_USER MIDL_user_free(void *memory) {
Arena *arena = TlsGetValue(arena_index);
if (!memory || !arena) return;
Allocation **link = &arena->head;
while (*link && (*link + 1) != memory) link = &(*link)->next;
if (*link) { Allocation *p = *link; *link = p->next; arena->total -= p->size; free(p); }
}
static void release_allocations(Arena *arena) {
while (arena->head) MIDL_user_free(arena->head + 1);
}
/* Stable numeric ABI, no returned peer/source strings or remotely sized data. */
typedef struct {
uint32_t leap, stratum, state, flags, last_result, size;
uint64_t last_sync, sync_age;
int64_t root_delay;
uint64_t root_dispersion;
int64_t phase;
} RmmClockStatus;
_Static_assert(sizeof(RmmClockStatus) == 64, "Rust numeric clock ABI");
_Static_assert(sizeof(RMM_W32TIME_STATUS) == 120, "MS-W32T x64 structure ABI");
/* Diagnostic-only numeric ABI. No strings, names, pointers or remote arrays
* leave C. A zero native return is meaningful only when return_present is1.
* Stages:10 compose,20 binding,30 auth,40 call-timeout,50 arena,
* 60 invoking,61 returned,62 raw numeric status,70 local guard,80 mapped,
* 90 contained RPC/SEH exception. Never used by the clock trust evaluator.
*/
typedef struct {
uint32_t stage, native_rpc_return, native_rpc_return_present, rpc_exception;
uint32_t status_present, ul_size, c_entries, p_entries_present;
} RmmClockTrace;
_Static_assert(sizeof(RmmClockTrace) == 32, "Rust numeric diagnostic ABI");
/* Diagnostic source variant only. No strings/parameters leave this function. */
typedef struct {
uint32_t generating_component, status, detection_location, flags;
int32_t number_of_parameters;
} RmmClockEeRecord;
typedef struct {
uint32_t capture_attempted, start_status, next_status, end_status, count, limit_reached;
RmmClockEeRecord records[4];
} RmmClockEeInfo;
_Static_assert(sizeof(RmmClockEeRecord) == 20, "numeric EEInfo record ABI");
_Static_assert(sizeof(RmmClockEeInfo) == 104, "bounded four-record EEInfo ABI");
static void capture_eeinfo(RmmClockEeInfo *out) {
RPC_ERROR_ENUM_HANDLE enumeration = {0};
out->capture_attempted = 1;
out->start_status = RpcErrorStartEnumeration(&enumeration);
if (out->start_status != RPC_S_OK) return;
for (unsigned i = 0; i < 4; ++i) {
RPC_EXTENDED_ERROR_INFO info = {0};
info.Version = RPC_EEINFO_VERSION;
info.Flags = 0;
info.NumberOfParameters = MaxNumberOfEEInfoParams;
out->next_status = RpcErrorGetNextRecord(&enumeration, FALSE, &info);
if (out->next_status != RPC_S_OK) break;
RmmClockEeRecord *record = &out->records[out->count++];
record->generating_component = info.GeneratingComponent;
record->status = info.Status;
record->detection_location = info.DetectionLocation;
record->flags = info.Flags;
record->number_of_parameters = info.NumberOfParameters;
/* ComputerName and Parameters are neither copied nor dereferenced.
* CopyStrings=FALSE: RPC owns all borrowed fields until EndEnumeration. */
}
out->limit_reached = out->count == 4;
out->end_status = RpcErrorEndEnumeration(&enumeration);
}
static uint32_t invoke_status(RPC_BINDING_HANDLE binding, RmmClockStatus *out, RmmClockTrace *trace, RmmClockEeInfo *eeinfo) {
RMM_W32TIME_STATUS *status = NULL;
unsigned long result = 0;
Arena arena = {0};
if (trace) trace->stage = 50;
if (!result && !InitOnceExecuteOnce(&arena_once, initialize_arena, NULL, NULL)) result = ERROR_NOT_ENOUGH_MEMORY;
if (!result && TlsGetValue(arena_index)) result = ERROR_BUSY;
if (!result && !TlsSetValue(arena_index, &arena)) result = GetLastError();
if (!result) {
RpcTryExcept {
if (trace) trace->stage = 60;
result = RmmW32TimeQueryStatus(binding, &status);
if (trace) {
trace->stage = 61; trace->native_rpc_return_present = 1;
trace->native_rpc_return = result;
}
if (!result) {
if (trace) {
trace->stage = 62; trace->status_present = status != NULL;
if (status) {
trace->ul_size = status->ulSize; trace->c_entries = status->cEntries;
trace->p_entries_present = status->pEntries != NULL;
}
}
if (!status || status->ulSize != sizeof(*status) || status->cEntries || status->pEntries) {
if (trace) trace->stage = 70;
result = RPC_X_BAD_STUB_DATA;
}
else {
if (trace) trace->stage = 80;
out->leap = status->eLeapIndicator; out->stratum = status->nStratum;
out->state = status->ulLcState; out->flags = status->ulTSFlags;
out->last_result = status->eLastSyncResult; out->size = status->ulSize;
out->last_sync = status->qwLastSyncTicks; out->sync_age = status->tpTimeLastGoodSync;
out->root_delay = status->toRootDelay; out->root_dispersion = status->tpRootDispersion;
out->phase = status->toSysPhaseOffset;
}
}
} RpcExcept(RpcExceptionFilter(RpcExceptionCode())) {
result = RpcExceptionCode();
if (eeinfo) capture_eeinfo(eeinfo); /* before any further RPC call */
if (trace) {trace->stage = 90; trace->rpc_exception = result;}
} RpcEndExcept
release_allocations(&arena);
TlsSetValue(arena_index, NULL);
}
return result;
}
static uint32_t pipe_query(RmmClockStatus *out, RmmClockTrace *trace, RmmClockEeInfo *eeinfo) {
RPC_WSTR text = NULL;
RPC_BINDING_HANDLE binding = NULL;
RPC_SECURITY_QOS qos = {0};
unsigned long result;
memset(out, 0, sizeof(*out));
if (trace) trace->stage = 10;
result = RpcStringBindingComposeW(NULL, (RPC_WSTR)L"ncacn_np", NULL,
(RPC_WSTR)L"\\pipe\\W32TIME_ALT", NULL, &text);
if (result) return result;
if (trace) trace->stage = 20;
result = RpcBindingFromStringBindingW(text, &binding);
RpcStringFreeW(&text);
if (result) return result;
qos.Version = RPC_C_SECURITY_QOS_VERSION;
qos.Capabilities = RPC_C_QOS_CAPABILITIES_DEFAULT;
qos.IdentityTracking = RPC_C_QOS_IDENTITY_STATIC;
qos.ImpersonationType = RPC_C_IMP_LEVEL_IDENTIFY;
if (trace) trace->stage = 30;
result = RpcBindingSetAuthInfoExW(binding, NULL, RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
RPC_C_AUTHN_WINNT, NULL, RPC_C_AUTHZ_NONE, &qos);
if (!result) {
if (trace) trace->stage = 40;
result = RpcBindingSetOption(binding, RPC_C_OPT_CALL_TIMEOUT, 1500);
}
if (!result) result = invoke_status(binding, out, trace, eeinfo);
RpcBindingFree(&binding);
return result;
}
uint32_t rmm_clock_query(RmmClockStatus *out) { return pipe_query(out, NULL, NULL); }
uint32_t rmm_clock_query_trace(RmmClockTrace *trace) {
RmmClockStatus ignored = {0};
memset(trace, 0, sizeof(*trace));
return pipe_query(&ignored, trace, NULL);
}
/* Kernel-authenticated ALPC only. No automatic fallback to named pipes.
* The expected SID is fixed locally, never adopted from endpoint metadata.
*/
static uint32_t alpc_query(RmmClockStatus *out, unsigned control) {
RPC_IF_ID id = {0};
RPC_EP_INQ_HANDLE inquiry = NULL;
RPC_STATUS result;
memset(out, 0, sizeof(*out));
result = UuidFromStringW((RPC_WSTR)L"8fb6d884-2388-11d0-8c35-00c04fda2795", &id.Uuid);
if (result) return result;
id.VersMajor = 4; id.VersMinor = 1;
result = RpcMgmtEpEltInqBegin(NULL, RPC_C_EP_MATCH_BY_IF, &id, RPC_C_VERS_EXACT, NULL, &inquiry);
if (result) return result;
for (unsigned i=0; i<16; ++i) {
RPC_IF_ID actual = {0};
RPC_BINDING_HANDLE binding = NULL;
UUID object = {0};
RPC_WSTR annotation = NULL, text = NULL, protocol = NULL;
result = RpcMgmtEpEltInqNextW(inquiry, &actual, &binding, &object, &annotation);
if (annotation) RpcStringFreeW(&annotation);
if (result) break;
result = RpcBindingToStringBindingW(binding, &text);
if (!result) result = RpcStringBindingParseW(text, NULL, &protocol, NULL, NULL, NULL);
int local = !result && !wcscmp((wchar_t *)protocol, L"ncalrpc");
if (protocol) RpcStringFreeW(&protocol);
if (text) RpcStringFreeW(&text);
if (result) {RpcBindingFree(&binding);break;}
if (local) {
_Alignas(8) BYTE expected_sid[SECURITY_MAX_SID_SIZE];
_Alignas(8) BYTE service_sid[SECURITY_MAX_SID_SIZE];
_Alignas(8) BYTE acl_buffer[sizeof(ACL) + sizeof(ACCESS_ALLOWED_ACE) + SECURITY_MAX_SID_SIZE];
SECURITY_DESCRIPTOR descriptor;
WCHAR domain[64];
DWORD domain_size = sizeof(domain) / sizeof(domain[0]);
DWORD service_sid_size = sizeof(service_sid);
SID_NAME_USE sid_type;
DWORD sid_size = sizeof(expected_sid);
RmmRpcQosV5 qos = {0};
/* An account-only SID19 binding also accepts other LocalService
* processes, including our network agent. The client-owned V5
* descriptor therefore requires the separate W32Time service SID.
* No descriptor/identity is obtained from endpoint metadata.
* Controls are fixed read-only diagnostics, never production modes.
*/
if (!CreateWellKnownSid(control == 1 ? WinLocalSystemSid : WinLocalServiceSid,
NULL, expected_sid, &sid_size)) result = GetLastError();
if (!result && !LookupAccountNameW(NULL,
control == 2 ? L"NT SERVICE\\RmmDiscoveryWindows" : L"NT SERVICE\\W32Time",
service_sid, &service_sid_size, domain, &domain_size, &sid_type)) result = GetLastError();
if (!result && (!IsValidSid(service_sid) || service_sid_size > sizeof(service_sid))) result = ERROR_INVALID_SID;
if (!result && !InitializeAcl((PACL)acl_buffer, sizeof(acl_buffer), ACL_REVISION)) result = GetLastError();
if (!result && !AddAccessAllowedAce((PACL)acl_buffer, ACL_REVISION, GENERIC_ALL, service_sid)) result = GetLastError();
if (!result && !InitializeSecurityDescriptor(&descriptor, SECURITY_DESCRIPTOR_REVISION)) result = GetLastError();
if (!result && !SetSecurityDescriptorDacl(&descriptor, TRUE, (PACL)acl_buffer, FALSE)) result = GetLastError();
if (!result) {
qos.Version = 5; /* RPC_C_SECURITY_QOS_VERSION_5 */
qos.Capabilities = RPC_C_QOS_CAPABILITIES_MUTUAL_AUTH;
qos.IdentityTracking = RPC_C_QOS_IDENTITY_STATIC;
qos.ImpersonationType = RPC_C_IMP_LEVEL_IDENTIFY;
qos.Sid = expected_sid;
qos.EffectiveOnly = TRUE;
qos.ServerSecurityDescriptor = &descriptor;
result = RpcBindingSetAuthInfoExW(binding, NULL, RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
RPC_C_AUTHN_WINNT, NULL, RPC_C_AUTHZ_NONE, (RPC_SECURITY_QOS *)&qos);
if (!result) result = invoke_status(binding, out, NULL, NULL);
}
RpcBindingFree(&binding);
break; /* no retry, alternate identity, endpoint or weaker transport */
}
RpcBindingFree(&binding);
result = EPT_S_NOT_REGISTERED;
}
RpcMgmtEpEltInqDone(&inquiry);
return result == RPC_X_NO_MORE_ENTRIES ? EPT_S_NOT_REGISTERED : result;
}
uint32_t rmm_clock_alpc_query(RmmClockStatus *out) { return alpc_query(out, 0); }
uint32_t rmm_clock_wrong_account(RmmClockStatus *out) { return alpc_query(out, 1); }
uint32_t rmm_clock_wrong_service(RmmClockStatus *out) { return alpc_query(out, 2); }
/* Exactly one original authenticated pipe query; EEInfo is observation only. */
uint32_t rmm_clock_query_trace_eeinfo(RmmClockTrace *trace, RmmClockEeInfo *eeinfo) {
RmmClockStatus ignored = {0};
memset(trace, 0, sizeof(*trace));
memset(eeinfo, 0, sizeof(*eeinfo));
return pipe_query(&ignored, trace, eeinfo);
}
+234
View File
@@ -0,0 +1,234 @@
#!/usr/bin/env python3
"""Parent-only native SYSTEM trace bootstrap: prepare, once start, read, cleanup.
Readback is strictly read-only. Cleanup is a separate explicit phase and may
remove only this exact stopped diagnostic service. Never changes W32Time/RMM.
"""
import argparse
import base64
import datetime as dt
import hashlib
import json
import os
from pathlib import Path
import re
import shlex
import stat
import subprocess
import sys
import uuid
ROOT = Path(__file__).resolve().parents[3]
HERE = Path(__file__).resolve().parent
STATE = ROOT / 'devstate/windows-clock-eeinfo-trace'
ACCESS_ROOT = Path('/home/kevin/Schreibtisch/Coding/rust-discovery')
def require(value,message):
if not value: raise RuntimeError(message)
def sha(path):
return hashlib.sha256(Path(path).read_bytes()).hexdigest()
def pairs(items):
result = {}
for name,value in items:
require(name not in result,'duplicate JSON key'); result[name] = value
return result
def private(path,directory=False):
item = Path(path).lstat()
require(item.st_uid == os.getuid() and stat.S_IMODE(item.st_mode) == (0o700 if directory else 0o600)
and (stat.S_ISDIR(item.st_mode) if directory else stat.S_ISREG(item.st_mode) and item.st_nlink == 1),'private owned path')
def load(path):
private(path); require(Path(path).stat().st_size <= 2*1024*1024,'bounded private JSON')
return json.loads(Path(path).read_bytes(),object_pairs_hook=pairs)
def save(path,value):
private(path.parent,True)
fd = os.open(path,os.O_CREAT|os.O_EXCL|os.O_WRONLY|os.O_NOFOLLOW,0o600)
with os.fdopen(fd,'w') as output:
json.dump(value,output,indent=2); output.flush(); os.fsync(output.fileno())
SCRIPT = r'''
$ErrorActionPreference='Stop';$p=([Console]::In.ReadLine()|ConvertFrom-Json)
$id=[guid]::ParseExact($p.id,'D').ToString()
if($id-cne$p.id-or$p.profile-cne'clock-system-eeinfo-v1'-or$p.action-notin@('prepare','start','readback','cleanup')-or$p.binary_sha256-notmatch'^[a-f0-9]{64}$'-or$p.manifest_sha256-notmatch'^[a-f0-9]{64}$'-or$p.script_sha256-notmatch'^[a-f0-9]{64}$'){throw 'Fixed SYSTEM diagnostic request'}
$root='C:\ProgramData\RustDiscoveryBootstrap';$name='RmmClockSystemEeInfoDiagnostic';$case=Join-Path $root ('clock-eeinfo-trace-'+$id);$exe=Join-Path $case 'ClockSystemEeInfoTrace.exe';$command='"'+$exe+'" --service '+$id
function Test-RmmTracePrivate($path,$dir){$i=Get-Item -LiteralPath $path -Force;if($i.PSIsContainer-ne$dir-or($i.Attributes-band[IO.FileAttributes]::ReparsePoint)){throw 'Private object type'};$a=Get-Acl -LiteralPath $path;if($a.GetOwner([Security.Principal.SecurityIdentifier]).Value-notin@('S-1-5-18','S-1-5-32-544')){throw 'Private object owner'};$rules=@($a.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier]));if(!$rules.Count){throw 'Empty private ACL'};foreach($e in $rules){if($e.AccessControlType-ne'Allow'-or$e.IdentityReference.Value-notin@('S-1-5-18','S-1-5-32-544')-or($e.PropagationFlags-band[Security.AccessControl.PropagationFlags]::InheritOnly)){throw 'Broad private ACL'}}}
function Write-RmmTraceNew($path,$value){$f=[IO.File]::Open($path,[IO.FileMode]::CreateNew,[IO.FileAccess]::Write,[IO.FileShare]::Read);try{$b=[Text.Encoding]::UTF8.GetBytes(($value|ConvertTo-Json -Depth 12 -Compress));$f.Write($b,0,$b.Length);$f.Flush($true)}finally{$f.Dispose()}}
function Get-RmmTraceJson($path){Test-RmmTracePrivate $path $false;if((Get-Item -LiteralPath $path).Length-gt16384){throw 'Small diagnostic receipt'};return(Get-Content -LiteralPath $path -Raw|ConvertFrom-Json)}
function Get-RmmTraceService{return(Get-CimInstance Win32_Service -Filter "Name='RmmClockSystemEeInfoDiagnostic'" -OperationTimeoutSec 5)}
function Test-RmmTraceService($s){if($s-and($s.PathName-cne$command-or$s.StartName-cne'LocalSystem'-or$s.StartMode-cne'Manual')){throw 'Only own exact temporary service'}}
if($p.action-eq'readback'-and!(Test-Path -LiteralPath $case)){@{id=$id;status='remote_case_absent';read_only=$true}|ConvertTo-Json -Compress;exit 0}
Test-RmmTracePrivate $root $true
if($p.action-eq'prepare'){if((Test-Path -LiteralPath $case)-or(Get-RmmTraceService)){throw 'Existing case/service retained'};New-Item -ItemType Directory -Path $case|Out-Null;Test-RmmTracePrivate $case $true;Write-RmmTraceNew (Join-Path $case 'intent.json') $p;@{id=$id;prepared=$true}|ConvertTo-Json -Compress;exit 0}
Test-RmmTracePrivate $case $true;$old=Get-RmmTraceJson (Join-Path $case 'intent.json')
foreach($field in @('id','profile','binary_sha256','manifest_sha256','script_sha256','binary_bytes')){if($old.$field-cne$p.$field){throw 'Original exact diagnostic intent'}}
Test-RmmTracePrivate $exe $false;if((Get-Item -LiteralPath $exe).Length-ne$p.binary_bytes-or(Get-FileHash -LiteralPath $exe -Algorithm SHA256).Hash.ToLowerInvariant()-cne$p.binary_sha256){throw 'Exact diagnostic executable'}
$s=Get-RmmTraceService;Test-RmmTraceService $s
if($p.action-eq'start'){
if($s-or(Test-Path -LiteralPath (Join-Path $case 'start-intent.json'))){throw 'No repeated start; original readback only'}
Write-RmmTraceNew (Join-Path $case 'start-intent.json') @{id=$id;command=$command;binary_sha256=$p.binary_sha256;create_once=$true}
New-Service -Name $name -BinaryPathName $command -StartupType Manual|Out-Null
$s=Get-RmmTraceService;Test-RmmTraceService $s;if(!$s){throw 'Own service creation missing'}
Write-RmmTraceNew (Join-Path $case 'service-created.json') @{id=$id;command=$command;start_name=$s.StartName}
Write-RmmTraceNew (Join-Path $case 'service-start-intent.json') @{start_once=$true}
Start-Service -Name $name
$deadline=[DateTime]::UtcNow.AddSeconds(20)
do{$s=Get-RmmTraceService;Test-RmmTraceService $s;if(!$s-or$s.State-eq'Stopped'){break};Start-Sleep -Milliseconds 100}while([DateTime]::UtcNow-lt$deadline)
}
if($p.action-eq'cleanup'){
if(!$s){if(!(Test-Path -LiteralPath (Join-Path $case 'cleanup-intent.json'))){throw 'Missing service without bound cleanup'};@{id=$id;cleanup_verified=$true;already_absent=$true;read_only=$true}|ConvertTo-Json -Compress;exit 0}
if($s.State-cne'Stopped'){throw 'Cleanup only own bound stopped service'}
$created=Get-RmmTraceJson (Join-Path $case 'service-created.json');if($created.id-cne$id-or$created.command-cne$command-or$created.start_name-cne'LocalSystem'){throw 'Original service creation binding'}
if(Test-Path -LiteralPath (Join-Path $case 'cleanup-intent.json')){throw 'Cleanup already attempted; readback only'}
Write-RmmTraceNew (Join-Path $case 'cleanup-intent.json') @{id=$id;command=$command;delete_once=$true}
& "$env:WINDIR\System32\sc.exe" delete $name|Out-Null;if($LASTEXITCODE-ne0){throw 'Own stopped service deletion incomplete'}
if(Get-RmmTraceService){throw 'Own service still registered; readback only'}
Write-RmmTraceNew (Join-Path $case 'cleanup-completed.json') @{id=$id;service_absent=$true}
@{id=$id;cleanup_verified=$true;already_absent=$false;read_only=$false}|ConvertTo-Json -Compress;exit 0
}
$report=$null;$result=Join-Path $case 'result.json';if(Test-Path -LiteralPath $result){$report=Get-RmmTraceJson $result}
$cleaned=$false;$cleanupReceipt=Join-Path $case 'cleanup-completed.json';if(Test-Path -LiteralPath $cleanupReceipt){$c=Get-RmmTraceJson $cleanupReceipt;if($c.id-cne$id-or$c.service_absent-ne$true){throw 'Bound cleanup receipt'};$cleaned=$true}
@{id=$id;service_present=[bool]$s;service_state=$(if($s){$s.State}else{$null});service_exit_code=$(if($s){$s.ExitCode}else{$null});start_intent_present=(Test-Path -LiteralPath (Join-Path $case 'service-start-intent.json'));cleanup_intent_present=(Test-Path -LiteralPath (Join-Path $case 'cleanup-intent.json'));cleanup_completed=$cleaned;report=$report;read_only=($p.action-eq'readback');no_rmm_jobs=$true;no_w32time_change=$true;no_agent_change=$true}|ConvertTo-Json -Depth 12 -Compress
'''
def encoded_command():
script = 'try {\n'+SCRIPT+'\n} catch {[pscustomobject]@{bootstrap_error=$true;error_id=$_.FullyQualifiedErrorId;line=$_.InvocationInfo.ScriptLineNumber}|ConvertTo-Json -Compress;exit 1}'
return 'powershell.exe -NoLogo -NoProfile -NonInteractive -EncodedCommand '+base64.b64encode(script.encode('utf-16le')).decode()
def manifest(path):
path = path.absolute(); private(path.parent,True)
require(path.name == 'manifest.json' and path.parent.parent == STATE and re.fullmatch(r'build-[0-9a-f-]{36}',path.parent.name),'fixed local build manifest')
value = load(path)
require(value['profile'] == 'clock-system-eeinfo-v1' and value['schema_version'] == 1
and value['native_executed'] is False and value['clock_qualified'] is False and value['product_gate_open'] is False
and value['powershell_ast_passed'] is True and value['encoded_command_characters'] == len(encoded_command()) < 32767
and value['script_sha256'] == hashlib.sha256(SCRIPT.encode()).hexdigest(),'same reviewed nonqualifying diagnostic source')
require(value['original_wrapper_sha256'] == '74aceb6e2b70c5dd628fae069a842c356c20300b8c8ab12754258c78eaf295c8'
and sha(path.parent / 'wrapper-source.diff') == value['wrapper_diff_sha256'],'same exact observational source delta')
for name,digest in value['own_sources'].items():require(sha(ROOT / name) == digest,'same original local driver source')
for name in ('artifact','linked'):
item=value[name];p=Path(item['path']);require(p.parent == path.parent / 'output','fixed retained PE path');private(p);require(sha(p) == item['sha256'],'retained exact diagnostic PE')
require(Path(value['artifact']['path']).stat().st_size == value['artifact']['bytes'],'exact PE size')
return value
def access(root):
require(root == ACCESS_ROOT and root.resolve() == root,'existing Main access root only')
sys.path.insert(0,str(ROOT / 'deploy'))
import vm_access_check
config = vm_access_check.load_config(root / 'credentials/server.conf')
require(config['address'] == '88.99.80.202' and config['username'] == 'root' and config.get('port','22') == '22','fixed existing cloud reverse jump')
record=load(root / 'credentials/windows-dev-access.json');expiry=dt.datetime.fromisoformat(record['expires_at'])
require(expiry.utcoffset() is not None and dt.datetime.now(dt.timezone.utc) < expiry,'current existing access only')
private(root / 'credentials',True);private(root / 'credentials/windows-dev.known_hosts')
key=str(Path(config['ssh_key_path']).expanduser())
jump=['ssh','-F','/dev/null','-T','-p','22','-i',key,'-o','StrictHostKeyChecking=yes','-o','BatchMode=yes','-o','ForwardAgent=no','-o','IdentitiesOnly=yes','-W','127.0.0.1:22240','root@88.99.80.202']
prefix=['ssh','-F','/dev/null','-T','-i',key,'-o','ProxyCommand='+shlex.join(jump),'-o','HostKeyAlias=rmm-windows-dev','-o','UserKnownHostsFile='+str(root / 'credentials/windows-dev.known_hosts'),'-o','GlobalKnownHostsFile=/dev/null','-o','StrictHostKeyChecking=yes','-o','BatchMode=yes','-o','IdentitiesOnly=yes','-o','ForwardAgent=no','-o','ConnectTimeout=10','rmm-dev@127.0.0.1']
require(record['ssh_prefix'] == prefix,'original pinned transport only')
return prefix
def run_transport(args,data,folder):
try:
done=subprocess.run(args,input=data,capture_output=True,timeout=50)
save(folder / ('transport-'+str(uuid.uuid4())+'.json'),dict(returncode=done.returncode,stdout_b64=base64.b64encode(done.stdout).decode(),stderr_b64=base64.b64encode(done.stderr).decode()))
require(done.returncode == 0,'transport incomplete; original readback only')
return done.stdout
except subprocess.TimeoutExpired as error:
save(folder / ('transport-timeout-'+str(uuid.uuid4())+'.json'),dict(timed_out=True,stdout_b64=base64.b64encode(error.stdout or b'').decode(),stderr_b64=base64.b64encode(error.stderr or b'').decode()))
raise RuntimeError('lost reply; no repeated operation') from None
def rpc(prefix,payload,folder):
value=json.loads(run_transport(prefix+[encoded_command()],(json.dumps(payload)+'\n').encode(),folder).decode('utf-8-sig'),object_pairs_hook=pairs)
require(isinstance(value,dict) and 'bootstrap_error' not in value,'remote diagnostic incomplete')
return value
def check_report(value,ident):
require(value['id'] == ident and value['no_rmm_jobs'] is True and value['no_w32time_change'] is True and value['no_agent_change'] is True,'exact nonproduct diagnostic case')
report=value.get('report')
if report is None:return False
require(report['schema_version'] == 1 and report['profile'] == 'clock-system-eeinfo-v1' and report['case_id'] == ident
and report['token_system'] is True and report['read_only'] is True and report['diagnostic_only'] is True
and report['query_invocations'] == 1 and report['clock_qualified'] is False and report['adapter_qualified'] is False
and report['product_gate_open'] is False,'actual SYSTEM token and single nonqualifying trace')
fields={'stage','native_rpc_return','native_rpc_return_present','rpc_exception','status_present','ul_size','c_entries','p_entries_present'}
require(set(report['trace']) == fields and type(report['rpc_code']) is int and 0 <= report['rpc_code'] < 2**32
and all(type(n) is int and 0 <= n < 2**32 for n in report['trace'].values()),'bounded numeric trace only')
ee=report['eeinfo']
require(set(ee) == {'capture_attempted','start_status','next_status','end_status','count','limit_reached','records'}
and all(type(ee[k]) is int and 0 <= ee[k] < 2**32 for k in ('capture_attempted','start_status','next_status','end_status','count','limit_reached'))
and ee['capture_attempted'] in (0,1) and 0 <= ee['count'] <= 4 and len(ee['records']) == ee['count']
and ee['limit_reached'] == int(ee['count'] == 4),'four-record numeric EEInfo budget')
record_fields={'generating_component','status','detection_location','flags','number_of_parameters'}
for record in ee['records']:
require(set(record) == record_fields and all(type(n) is int and 0 <= n < 2**32 for n in record.values())
and record['number_of_parameters'] <= 4,'numeric EEInfo fields only; no parameter contents')
if report['trace']['stage'] == 90:require(ee['capture_attempted'] == 1 and report['rpc_code'] == report['trace']['rpc_exception'],'original exception code preserved before immediate capture')
return (value['service_state'] == 'Stopped' and value['service_exit_code'] == 0) or (value['service_present'] is False and value['cleanup_completed'] is True)
def execute(action,path,root,ident):
os.umask(0o077);STATE.mkdir(mode=0o700,exist_ok=True);private(STATE,True)
value=manifest(path);prefix=access(root)
if action == 'prepare':
require(not ident,'new diagnostic case only');ident=str(uuid.uuid4());folder=STATE / ident;folder.mkdir(mode=0o700)
payload=dict(id=ident,profile='clock-system-eeinfo-v1',manifest_sha256=sha(path),binary_sha256=value['artifact']['sha256'],binary_bytes=value['artifact']['bytes'],script_sha256=value['script_sha256'])
save(folder / 'intent.json',dict(payload=payload,manifest_path=str(path.absolute()),access_root=str(root)))
print(json.dumps(dict(case_id=ident,prepare_once=True)),flush=True)
prepared=rpc(prefix,dict(payload,action='prepare'),folder);save(folder / 'prepared-remote.json',prepared);require(prepared == dict(id=ident,prepared=True),'new private remote case')
save(folder / 'upload-intent.json',dict(binary_sha256=payload['binary_sha256'],upload_once=True))
args=['sftp']+[p for p in prefix[1:-1] if p != '-T']+['-b','-',prefix[-1]]
destination='/C:/ProgramData/RustDiscoveryBootstrap/clock-eeinfo-trace-'+ident+'/ClockSystemEeInfoTrace.exe'
run_transport(args,('put '+json.dumps(value['artifact']['path'])+' '+json.dumps(destination)+'\n').encode(),folder)
save(folder / 'upload-completed.json',dict(uploaded=True));print(json.dumps(dict(case_id=ident,prepared=True,service_started=False)));return
require(str(uuid.UUID(ident)) == ident,'canonical original case')
folder=STATE / ident;private(folder,True);original=load(folder / 'intent.json');payload=original['payload']
require(original['manifest_path'] == str(path.absolute()) and original['access_root'] == str(root)
and payload['manifest_sha256'] == sha(path) and payload['script_sha256'] == value['script_sha256'],'original same-case input tuple')
if action in ('start','cleanup'):
if action == 'start':require(load(folder / 'upload-completed.json')['uploaded'] is True,'completed original upload')
save(folder / (action+'-intent.json'),dict(action=action,once=True))
result=rpc(prefix,dict(payload,action=action),folder);save(folder / ('readback-'+str(uuid.uuid4())+'.json'),result)
if action == 'cleanup':
require(result.get('id') == ident and result.get('cleanup_verified') is True,'own stopped service cleanup only')
print(json.dumps(dict(case_id=ident,cleanup_verified=True)));return
if result.get('status'):
require(action == 'readback' and result['status'] == 'remote_case_absent','read-only original partial status')
print(json.dumps(dict(case_id=ident,complete=False,retry_allowed=False)));return
complete=check_report(result,ident)
if complete:
destination=folder / 'diagnostic-result.json'
receipt=dict(complete=True,manifest_sha256=sha(path),actual=result,clock_qualified=False,product_gate_open=False)
if destination.exists():require(load(destination)['actual']['report'] == result['report'],'preserve original numeric report')
else:save(destination,receipt)
print(json.dumps(dict(case_id=ident,diagnostic_complete=complete,rpc_code=result['report']['rpc_code'] if complete else None,
stage=result['report']['trace']['stage'] if complete else None,eeinfo_count=result['report']['eeinfo']['count'] if complete else None,clock_qualified=False,cleanup_separate=True)))
def main():
parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('action',choices=('prepare','start','readback','cleanup'))
parser.add_argument('--manifest',type=Path,required=True);parser.add_argument('--access-root',type=Path,required=True);parser.add_argument('--id')
parser.add_argument('--execute-native',action='store_true');args=parser.parse_args()
require((args.action == 'readback' and not args.execute_native) or (args.action != 'readback' and args.execute_native),'explicit native effect phase; readback only reads')
execute(args.action,args.manifest,args.access_root,args.id)
if __name__ == '__main__':
try:main()
except Exception as error:
print(json.dumps(dict(error='CLOCK_SYSTEM_TRACE_NATIVE_INCOMPLETE',error_class=type(error).__name__,details_suppressed=True)))
raise SystemExit(2) from None
@@ -0,0 +1,135 @@
/* Standalone diagnostic only. The original C/Auth/MIDL inputs are linked
* unchanged. Exactly one trace query, only under this process's SYSTEM token.
* No clock setter, token impersonation, NTP/ACL/provider or product gate. */
#define _WIN32_WINNT 0x0a00
#include <windows.h>
#include <stdint.h>
#include <stdio.h>
#include <wchar.h>
typedef struct {
uint32_t stage, native_rpc_return, native_rpc_return_present, rpc_exception;
uint32_t status_present, ul_size, c_entries, p_entries_present;
} RmmClockTrace;
_Static_assert(sizeof(RmmClockTrace) == 32, "same diagnostic trace ABI");
typedef struct {
uint32_t generating_component, status, detection_location, flags;
int32_t number_of_parameters;
} RmmClockEeRecord;
typedef struct {
uint32_t capture_attempted, start_status, next_status, end_status, count, limit_reached;
RmmClockEeRecord records[4];
} RmmClockEeInfo;
_Static_assert(sizeof(RmmClockEeInfo) == 104, "same four-record numeric EEInfo ABI");
uint32_t rmm_clock_query_trace_eeinfo(RmmClockTrace *trace, RmmClockEeInfo *eeinfo);
static WCHAR service_name[] = L"RmmClockSystemEeInfoDiagnostic";
static WCHAR case_id[37];
static SERVICE_STATUS_HANDLE status_handle;
static SERVICE_STATUS service_status;
static DWORD WINAPI control(DWORD event, DWORD type, void *data, void *context) {
(void)event; (void)type; (void)data; (void)context;
return ERROR_CALL_NOT_IMPLEMENTED;
}
static DWORD own_system_token(void) {
HANDLE token = NULL;
DWORD needed = 0, result = ERROR_SUCCESS;
_Alignas(8) BYTE storage[4096];
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &token)) return GetLastError();
if (!GetTokenInformation(token, TokenUser, storage, sizeof(storage), &needed)) result = GetLastError();
else if (needed > sizeof(storage) || !IsWellKnownSid(((TOKEN_USER *)storage)->User.Sid, WinLocalSystemSid)) result = ERROR_ACCESS_DENIED;
CloseHandle(token);
return result;
}
static DWORD write_result(uint32_t rpc, const RmmClockTrace *trace, const RmmClockEeInfo *eeinfo) {
WCHAR path[256];
char id[37], report[4096];
DWORD written = 0, result = ERROR_SUCCESS;
for (unsigned i = 0; i < 37; ++i) id[i] = (char)case_id[i];
int count = swprintf(path, sizeof(path) / sizeof(path[0]),
L"C:\\ProgramData\\RustDiscoveryBootstrap\\clock-eeinfo-trace-%ls\\result.json", case_id);
if (count <= 0 || count >= (int)(sizeof(path) / sizeof(path[0]))) return ERROR_INVALID_PARAMETER;
count = snprintf(report, sizeof(report),
"{\"schema_version\":1,\"profile\":\"clock-system-eeinfo-v1\",\"case_id\":\"%s\","
"\"token_system\":true,\"read_only\":true,\"diagnostic_only\":true,\"query_invocations\":1,"
"\"clock_qualified\":false,\"adapter_qualified\":false,\"product_gate_open\":false,\"rpc_code\":%lu,"
"\"trace\":{\"stage\":%lu,\"native_rpc_return\":%lu,\"native_rpc_return_present\":%lu,"
"\"rpc_exception\":%lu,\"status_present\":%lu,\"ul_size\":%lu,\"c_entries\":%lu,\"p_entries_present\":%lu}}\n",
id, (unsigned long)rpc, (unsigned long)trace->stage,
(unsigned long)trace->native_rpc_return, (unsigned long)trace->native_rpc_return_present,
(unsigned long)trace->rpc_exception, (unsigned long)trace->status_present,
(unsigned long)trace->ul_size, (unsigned long)trace->c_entries, (unsigned long)trace->p_entries_present);
if (count <= 0 || count >= (int)sizeof(report)) return ERROR_BUFFER_OVERFLOW;
if (count < 3 || eeinfo->count > 4) return ERROR_INVALID_DATA;
/* Replace only the final root-object closure; original trace stays intact. */
size_t used = (size_t)count - 2;
int appended = snprintf(report + used, sizeof(report) - used,
",\"eeinfo\":{\"capture_attempted\":%lu,\"start_status\":%lu,\"next_status\":%lu,"
"\"end_status\":%lu,\"count\":%lu,\"limit_reached\":%lu,\"records\":[",
(unsigned long)eeinfo->capture_attempted, (unsigned long)eeinfo->start_status,
(unsigned long)eeinfo->next_status, (unsigned long)eeinfo->end_status,
(unsigned long)eeinfo->count, (unsigned long)eeinfo->limit_reached);
if (appended <= 0 || (size_t)appended >= sizeof(report) - used) return ERROR_BUFFER_OVERFLOW;
used += (size_t)appended;
for (unsigned i = 0; i < eeinfo->count; ++i) {
const RmmClockEeRecord *record = &eeinfo->records[i];
appended = snprintf(report + used, sizeof(report) - used,
"%s{\"generating_component\":%lu,\"status\":%lu,\"detection_location\":%lu,"
"\"flags\":%lu,\"number_of_parameters\":%ld}", i ? "," : "",
(unsigned long)record->generating_component, (unsigned long)record->status,
(unsigned long)record->detection_location, (unsigned long)record->flags,
(long)record->number_of_parameters);
if (appended <= 0 || (size_t)appended >= sizeof(report) - used) return ERROR_BUFFER_OVERFLOW;
used += (size_t)appended;
}
appended = snprintf(report + used, sizeof(report) - used, "]}}\n");
if (appended <= 0 || (size_t)appended >= sizeof(report) - used) return ERROR_BUFFER_OVERFLOW;
used += (size_t)appended;
count = (int)used;
HANDLE file = CreateFileW(path, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_NEW,
FILE_ATTRIBUTE_NORMAL | FILE_FLAG_WRITE_THROUGH, NULL);
if (file == INVALID_HANDLE_VALUE) return GetLastError();
if (!WriteFile(file, report, (DWORD)count, &written, NULL) || written != (DWORD)count) result = ERROR_WRITE_FAULT;
else if (!FlushFileBuffers(file)) result = GetLastError();
CloseHandle(file);
return result;
}
static void WINAPI run_service(DWORD argc, WCHAR **argv) {
(void)argc; (void)argv;
status_handle = RegisterServiceCtrlHandlerExW(service_name, control, NULL);
if (!status_handle) return;
ZeroMemory(&service_status, sizeof(service_status));
service_status.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
service_status.dwCurrentState = SERVICE_RUNNING;
service_status.dwControlsAccepted = 0;
if (!SetServiceStatus(status_handle, &service_status)) return;
DWORD result = own_system_token();
if (!result) {
RmmClockTrace trace = {0};
RmmClockEeInfo eeinfo = {0};
uint32_t rpc = rmm_clock_query_trace_eeinfo(&trace, &eeinfo); /* exactly one fixed call */
result = write_result(rpc, &trace, &eeinfo);
}
service_status.dwCurrentState = SERVICE_STOPPED;
service_status.dwWin32ExitCode = result;
SetServiceStatus(status_handle, &service_status);
}
int wmain(int argc, WCHAR **argv) {
if (argc != 3 || wcscmp(argv[1], L"--service") || wcslen(argv[2]) != 36) return ERROR_INVALID_PARAMETER;
for (unsigned i = 0; i < 36; ++i) {
WCHAR value = argv[2][i];
if (i == 8 || i == 13 || i == 18 || i == 23) {
if (value != L'-') return ERROR_INVALID_PARAMETER;
} else if (!((value >= L'0' && value <= L'9') || (value >= L'a' && value <= L'f'))) return ERROR_INVALID_PARAMETER;
case_id[i] = value;
}
case_id[36] = 0;
SERVICE_TABLE_ENTRYW table[] = {{service_name, run_service}, {NULL, NULL}};
if (!StartServiceCtrlDispatcherW(table)) return (int)GetLastError();
return 0;
}
+190
View File
@@ -0,0 +1,190 @@
# Begrenzter EEInfo-Nachfolger: Fehlerlage statt Ursachenbehauptung
Stand 2026-11-14: **separat implementiert, lokal gebaut und durch den
verantwortlichen Rootprozess einmal auf der Windows-VM ausgeführt**. Dieser
Subagent führte keine VM-Aktion aus. Der tatsächliche vorherige SYSTEM-Vergleich
`562ff9de-67ff-48a1-96f0-c2474b3b0777` meldete wie LocalService RPC5/Stage90
ohne Status oder normalen RPCreturn. Die einfache Erklärung durch ausschließlich
LocalService ist damit nicht belegt. Authentifizierungs-/Autorisierungsschicht
und tatsächliche serverseitige Calleridentität bleiben offen. Kein Produktgate
wird aus diesem Befund geöffnet.
## Microsoft-Quellen und konkrete Grenzen
Die [V5-QoS-Dokumentation](https://learn.microsoft.com/en-us/windows/win32/api/rpcdce/ns-rpcdce-rpc_security_qos_v5_w)
beschreibt den Serverdescriptor nur allgemein. Sie dokumentiert für unser
lokales `ncacn_np` keinen vollständigen Vertrag, der genau den tatsächlichen
Serverprozesstoken einschließlich W32Time-Service-SID beweist. Die
[SDK-Deklaration](https://github.com/microsoft/win32metadata/blob/main/generation/WinSDK/RecompiledIdlHeaders/shared/rpcdce.h)
belegt das Layout, nicht diese Laufzeitsemantik. Microsoft warnt außerdem, dass
NTLM erfolgreiche Mutual-Auth-Aushandlung melden kann, obwohl echte gegenseitige
Authentifizierung fehlt. V5, ein gesetztes Flag oder erfolgreicher SetAuth-Aufruf
sind deshalb kein selbständiger Konto-/Service-SID-Nachweis. Das ist eine
verbleibende Nachweislücke, keine Behauptung, der Descriptor könne grundsätzlich
nie wirksam sein. Microsoft-Q&A-Erfahrungsberichte wurden nicht als verbindliche
Produktgarantie verwendet.
Die LocalService-Beschreibung anonymer **Netzwerk**credentials beweist keinen
anonymen SSPI-Caller dieser lokalen NPFS-Verbindung. Laut
[RPC-Credentialsvertrag](https://learn.microsoft.com/en-us/windows/win32/rpc/client-authentication-credentials)
werden implizite Credentials aus Thread-/Prozesstoken gewonnen. Die tatsächlich
vom Server verwendete Identität lässt sich nicht einfach aus einem Client-
Account oder den konfigurierten Bindungsoptionen ablesen. Die dokumentierte
[Callattributes-Struktur](https://learn.microsoft.com/en-us/windows/win32/api/rpcasync/ns-rpcasync-rpc_call_attributes_v2_w)
enthält Authentifizierungsdaten und NullSession, wird jedoch serverseitig mit
`RpcServerInqCallAttributes` abgefragt; sie ist keine Clientabfrage in W32Time.
EEInfo kann die Fehlerlage eingrenzen: Microsoft benennt unter anderem SSP,
NPFS/Redirector/Named Pipe und Authz als
[GeneratingComponents](https://learn.microsoft.com/en-us/windows/win32/rpc/understanding-extended-error-information).
Eine einzelne Zahl beweist weiterhin weder einen anonymen Caller noch die
konkrete verweigernde ACL. Fehlende Records sind kein Gegenbeweis:
[EEInfo ist standardmäßig grenzüberschreitend deaktiviert](https://learn.microsoft.com/en-us/windows/win32/rpc/security-and-extended-error-information).
Der neue Versuch schaltet keine Registry-/Audit-/EEInfo-Policy um.
## Exakt begrenztes Source-Delta
Neue sibling-Dateien unter `deploy/windows/clock-eeinfo-trace/`, eigener Dienst
`RmmClockSystemEeInfoDiagnostic`, eigene History. Original131, alter Wrapper
und vorheriger SYSTEMrunner bleiben unverändert und readbackfähig.
`clock_rpc_eeinfo.c` ist eine sichtbare Diagnosequellvariante gegenüber
`clock_rpc.c`, Original-SHA256
`74aceb6e2b70c5dd628fae069a842c356c20300b8c8ab12754258c78eaf295c8`.
Der Build speichert `wrapper-source.diff` samt Hash. Änderungen ausschließlich:
`rpcasync.h`, fester104Byte-Numerikpuffer, Parameterweitergabe, neuer
Diagnoseexport und Capture im bestehenden `RpcExcept` direkt nach dem lokal
gespeicherten ursprünglichen Exceptioncode. Auth-/Endpunkt-/NDR-/QoSzeilen
bleiben gleich. Originalcode5 wird nicht durch Enum-Returncodes ersetzt.
Die tatsächlichen SDK-Prototypen werden aus dem Header verwendet:
`RpcErrorStartEnumeration(RPC_ERROR_ENUM_HANDLE*)`,
`RpcErrorGetNextRecord(RPC_ERROR_ENUM_HANDLE*, BOOL, RPC_EXTENDED_ERROR_INFO*)`
und `RpcErrorEndEnumeration(RPC_ERROR_ENUM_HANDLE*)`.
Microsoft verlangt den [sofortigen Enumerationsstart](https://learn.microsoft.com/en-us/windows/win32/api/rpcasync/nf-rpcasync-rpcerrorstartenumeration),
da spätere Aufrufe die Threaddaten überschreiben können. Der Start steht vor
jedem weiteren RPC-/BindingFree-Aufruf im Handler.
Höchstens vier NextRecord-Aufrufe, keine fünfte Abfrage. Je Record verlassen
nur GeneratingComponent, Status, DetectionLocation, Flags und NumberOfParameters
C. Keine Parameterwerte, Strings, ComputerName, Binary-/Pointerdaten oder
Zeit-/Namensfelder werden kopiert/exportiert. Gemäß
[GetNextRecord](https://learn.microsoft.com/en-us/windows/win32/api/rpcasync/nf-rpcasync-rpcerrorgetnextrecord)
werden Version, Flags und **MaxNumberOfEEInfoParams** als Eingabekapazität gesetzt;
Nullkapazität könnte sonst BUFFER_TOO_SMALL auslösen. CopyStringsFALSE bedeutet
geborgte RPC-Daten, die der Aufrufer weder verändert noch freigibt. Bei
erfolgreichem Start wird immer
[EndEnumeration](https://learn.microsoft.com/en-us/windows/win32/api/rpcasync/nf-rpcasync-rpcerrorendenumeration)
aufgerufen. `limit_reached=1` bedeutet ausschließlich erreichtes Viererbudget,
keinen Beweis eines weiteren Records.
Die neue SID18-Servicehülle ruft genau einmal denselben Tracepfad auf. Höchstens
4096Bytes Ergebnis, ausschließlich numerische Zusatzdaten und feste Labels;
clock/adapter/productgate bleiben false. Keine Impersonationserhöhung,
Anonymous-/unauthenticated-Fallbacks, ACL-, NTP- oder Accountänderung.
Prepare/Start/Readback/Cleanup bleiben getrennt; Cleanup nur eigener eindeutig
gebundener gestoppter Dienst, Remote-Readback ausschließlich lesend.
## Tatsächlich lokal geprüft
```text
python3 deploy/windows/clock-eeinfo-trace/build.py
```
Offline im gepinnten bisherigen Image gebaut. Neue C-Hülle/Wrapper bestehen
`-Wall -Wextra -Werror`; nur dieselben drei bekannten Stilwarnungen am
unveränderten echten Microsoft-MIDL-Stub bleiben sichtbar. Kein Typ-/Security-
Warning wurde unterdrückt. Link/PE-x64-/Import-/private Manifestguards bestanden,
ebenso der tatsächliche PowerShell-AST-Lauf; EncodedCommand16718Zeichen.
Imports nur ADVAPI32/KERNEL32/RPCRT4/msvcrt.
Finaler Manifest:
`devstate/windows-clock-eeinfo-trace/build-8d33bc4b-a0ce-430e-aa5b-5d1dc112ecf0/manifest.json`,
SHA256 `2b10417c41ff5c293f71e303b703e8d883d3ba7bc361bb047417d5de66124b49`.
PE101312Bytes, SHA256
`cef50aa281069c76494f88ef893191e3978f9a3c66d162658f5914a5193d2787`.
Der frühere lokale Pack `9ca2ff31…` bleibt erhalten und wird nicht für die
Probe verwendet; der finale Driver bindet zusätzlich den sichtbaren Diff und
prüft ursprünglichen Exceptioncode gegen Originaltrace.
Acht manipulierte Record-/Reportfälle, Viererbudget, ursprünglicher RPCcode,
String-/Parameterverweigerung, kein Datenbeleg bei leerem EEInfo und rein
lesendes Readback wurden lokal mit ausdrücklich **simulierten** Reports geprüft.
Diese dürfen eine vollständig ausgeführte Diagnose darstellen, beweisen aber
keinen echten RPC-/Status-/Clockerfolg. `local-guards.json` kennzeichnet die
Mocks und `native_executed=false`; alte SYSTEMdateien wurden bytegleich
nachgeprüft. Keine SSH-/VM-/Dienst-/RMM-Aktion durch diesen Subagenten.
## Tatsächliche einmalige Root-Probe und getrenntes Readback
Root führte den freigegebenen finalen Pack im Fall
`e4e6e12f-6c1b-4bd2-8072-70c5e6634aa6` auf der Windows-VM aus. Der eigene
SYSTEM-Diagnosedienst meldete genau einen Queryaufruf und beendete sich mit
Service-Exitcode0; die RPC-Abfrage selbst blieb ausdrücklich fehlgeschlagen:
`token_system=true`, RPC5, Stage90, Exception5, kein normaler RPCreturn und kein
Statusobjekt. Service-Exit0 ist hier ausschließlich Abschluss der Diagnose.
Clock-, Adapter- und Produktgate blieben false. Kein RMM-Job entstand.
Die unmittelbar im Exceptionhandler erfassten numerischen EEInfo-Daten sind:
| Feld | Tatsächlicher Wert |
| --- | --- |
| capture_attempted / start_status | 1 / 0 |
| next_status / end_status | 1761 / 0 |
| count / limit_reached | 1 / 0 |
| generating_component / status | 2 / 5 |
| detection_location / flags / number_of_parameters | 1750 / 0 / 1 |
Keine Parameterwerte, Strings, Rechnernamen oder Binary-/Pointerdaten wurden
exportiert. Der lokal erhaltene `diagnostic-result.json` hat SHA256
`80accca4f99a2ede0ccb3fd0a21730f69a53a6310c6c6ead42aa4d958c56b6f4`.
Ein gesonderter lesender Aufruf lieferte dasselbe vollständige Reportobjekt:
`readback-2a256a82-5e0d-4895-b3d9-0a67cfa841e8.json`, SHA256
`93a1655fa4327579580e6df661ec7243af282af1f175735d882ccbd1ec9002b5`.
Die Dateien liegen im privaten ursprünglichen Caseverzeichnis unter
`devstate/windows-clock-eeinfo-trace/`; keine Zugangsdaten oder Transportpräfixe
gehören zum publizierbaren Beleg.
Root entfernte anschließend ausschließlich den eigenen gebundenen gestoppten
Diagnosedienst. Der separate Cleanupbeleg
`readback-a1ef841d-218e-4adc-9075-1af320baf1f5.json`, SHA256
`c03b535f21f430399f9ae3fbdca8d1e869b80ae6567b762eded04f208a68fcc3`,
meldet `cleanup_verified=true`; das war eine explizite Cleanupaktion, kein
lesender Aufruf. Root hat zusätzlich die vollständige Preservationprüfung
abgeschlossen: ursprüngliche Agent-/Helperdienste und Prozessgeburten, Codehashes,
FileIDs, PKI-/Datenbankzeugen und serverseitiger Zustand stimmen vor/nach exakt
überein. Keine neuen Jobs, Clockgate weiterhin false. Vorherbeleg-SHA256
`3d508df7a46b3ab181f9d9575432e544627609fed98c77dabb107a7798bcb87b`;
Nachherbeleg `eeinfo-trace-after.json` im ursprünglichen privaten
`windows-pipe-drain/devstate/windows-client/system-pipe-upgrade/14fb176a-f653-4573-a8d7-6f9fe47a3020/`-Kontext,
SHA256 `921cd12b8f90c0921a6a11ec48d3ef61d4fffb2f6f3979f5f8731d2ac6425240`.
Das ist ein Erhaltungsnachweis der Diagnose, kein erfolgreicher Clock-/Jobnachweis.
## Belegte Deutung und verbleibende Grenze
Microsoft ordnet [GeneratingComponent2 der RPC-Runtime zu](https://learn.microsoft.com/en-us/windows/win32/rpc/understanding-extended-error-information).
Status5 bezeichnet [Access denied](https://learn.microsoft.com/en-us/windows/win32/debug/system-error-codes--0-499-).
Dies benennt den meldenden Layer und den Fehler, weder die konkrete verweigernde
ACL noch den tatsächlichen serverseitigen Caller oder einen anonymen SSPIkontext.
DetectionLocation ist laut derselben EEInfo-Dokumentation ein von der
Implementierungsversion abhängiger interner Codeort. Die öffentliche
[Detection-Locations-Tabelle](https://learn.microsoft.com/en-us/windows/win32/rpc/extended-error-information-detection-locations)
gilt ausdrücklich für WindowsXP und enthält1750 nicht. Auch
[MS-EERR2.2.3](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-eerr/92064599-dc99-4e86-a887-b377a95ac678)
liefert keine Zuordnung für1750/Component2. Die geprüften Primärquellen erklären
diesen Windows-11-Codeort somit nicht. Die Zahl1750 ist hier außerdem kein
Win32-Returncode und darf nicht als dessen Fehlername dekodiert werden.
Der Enumstatus1761 ist gemäß [GetNextRecord-Vertrag](https://learn.microsoft.com/en-us/windows/win32/api/rpcasync/nf-rpcasync-rpcerrorgetnextrecord)
das normale Ende nach dem letzten erfolgreich gelesenen Record. Ein Record
wurde erfasst, das Viererbudget nicht erreicht; dies ist kein Enumfehler anstelle
des ursprünglichen RPC5. Flags0 meldet keine Missing-Record-Flags. Microsoft
beschreibt EEInfo dennoch ausdrücklich als [best effort und ungeeignet für Produktentscheidungslogik](https://learn.microsoft.com/en-us/windows/win32/rpc/reliability-of-extended-error-information):
eine vollständige Ursachen- oder Nichtanonymitätsgarantie folgt daraus nicht.
Die enge Diagnose hat damit einen tatsächlichen Runtime-EEInfo-Beleg geliefert,
keinen W32Time-Status oder Clocknachweis. Eine weitere Deutung des Codeorts
braucht einen zum tatsächlichen Windows-/RPC-Build passenden Primärnachweis.
Keine ACL-/Konto-/Auth-/NTPänderung und keine Ersatzclock/Brokerarchitektur wird
aus diesem Record abgeleitet; sämtliche Produktgates bleiben geschlossen.
+92
View File
@@ -0,0 +1,92 @@
# Clock: nächste Diagnosegrenzen, noch keine Implementierungsfreigabe
Historische Planungsnotiz vor der nativen MIDL-/EEInfo-Probe; deren tatsächliche
Ergebnisse stehen in [EEInfo-Diagnose](windows-clock-eeinfo-trace.md). Die hier
beschriebenen weiteren V5-Vergleiche wurden nicht ausgeführt.
Stand 2026-11-14. Diese Notiz ändert weder den eingefrorenen MIDL-Runner
`078bf230…` noch Clock-/RPC-Produktquellen. Keine Zielverbindung ausgeführt.
## MIDL-Signatur: tatsächlich statisch gelesene öffentliche Metadaten
Die gehashten NuGet-PE-Dateien `midl.exe` und `midlc.exe` enthalten denselben
Microsoft-Corporation-Code-Signing-Leaf, SHA-256
`0ba22e4765f7a160178ec90535c37f024916fbce0d9da63118d69662b5fed7eb`.
Sein Gültigkeitsintervall ist **2026-03-05 19:58:26 UTC bis
2027-03-03 19:58:26 UTC**, einschließlich Code-Signing-EKU. Das enthaltene
Zwischenzertifikat Microsoft Windows Code Signing PCA 2024 ist von
2024-08-08 bis 2035-06-23 datiert. Damit widerspricht eine Prüfung zum
14.11.2026 diesen eingebetteten Zeitintervallen nicht.
Der private Beleg `public-certificate-time-metadata.json` im MIDL-Downloadfall
`6b7fb9b1-0bb7-4880-850b-e6812d3df1b1` enthält die exakten Toolhashes und beide
öffentlichen Zertifikatsbags. Dies ist **kein** Nachweis von PE-Signatur,
Signerauswahl, Zertifikatskette, Widerruf oder vertrauenswürdigem Zeitstempel.
Die Ziel-Vertrauensspeicher und Online-Widerrufsprüfung bleiben ungeprüft.
Die zusätzliche `X509Chain.Build(SignerCertificate)`-Prüfung benutzt ohne
explizite VerificationTime das aktuelle Datum; die
[Microsoft-.NET-Framework-Quelle](https://github.com/microsoft/referencesource/blob/main/System/security/system/security/cryptography/x509/x509chainpolicy.cs)
setzt beim Reset `DateTime.Now`. Eine Dateisignatur mit gültigem vertrauenswürdigem
Timestamp kann dagegen auch nach Ablauf des Signierzertifikats zulässig bleiben,
wie Microsoft für [Authenticode-Zeitstempel](https://learn.microsoft.com/en-us/windows/win32/seccrypto/time-stamping-authenticode-signatures)
beschreibt. Eine separate heutige Blattkettenprüfung ist deshalb kein allgemeiner
Ersatz für die vollständige Dateisignatur-/Timestamp-Policy.
Für die **jetzt fest gepinnten** Tools besteht nach den gelesenen Metadaten kein
solcher Ablaufkonflikt. Der Runner bleibt unverändert streng. Scheitert die
native Prüfung, muss der genaue Grund erhalten werden; kein IgnoreNotTimeValid,
kein abgeschalteter Widerruf und kein neu importierter Trustanker als Abkürzung.
Soll später ein anderer, abgelaufener, aber timestamp-signierter Input nötig
werden, verlangt das einen eigenen geprüften Verifiervertrag: vollständige
[Authenticode-Dateipolicy](https://learn.microsoft.com/en-us/windows/win32/api/wintrust/nf-wintrust-winverifytrust),
Dateidigest, erlaubter Signer und belegte Timestamp-/Kettenprüfung statt eines
frei gesetzten historischen Prüfdatenwerts.
## Geplanter enger Named-Pipe-V5-Diagnosevergleich
Voraussetzung ist zuerst ein **tatsächlich zurückgelesener** MIDL-Header/-Stub
und ein nativer Opnum-6-Statusbeleg. Ein weiterer gleicher NDR-Fehler 1783 ist
kein Identitätsnachweis und darf nicht als negatives Sicherheitskontrollergebnis
gezählt werden. Produktive Clockbereitschaft bleibt unabhängig davon false.
Die [RPC-V5-Dokumentation](https://learn.microsoft.com/en-us/windows/win32/api/rpcdce/ns-rpcdce-rpc_security_qos_v5_w)
beschreibt `ServerSecurityDescriptor` zur Serveridentifikation und warnt, dass
NTLM trotz fehlender gegenseitiger Authentifizierung erfolgreiche
MUTUAL_AUTH-Verhandlung melden kann. `Sid` ist insbesondere für `ncalrpc`
beschrieben; die Wirkung der gewählten Kombination auf `ncacn_np` ist noch
nativ nachzuweisen. Ein gesetztes Flag oder erfolgreiche SetAuthInfo-Rückgabe
qualifiziert diese Kombination nicht.
Kleinster **noch nicht implementierter** Vergleich, getrennt vom bisherigen
Named-Pipe-/ALPC-Pfad:
1. Exakter lokaler authentifizierter Endpunkt `\\pipe\\W32TIME_ALT`, Interface
4.1/Opnum 6, bestehender C-SEH-/Allocator-/Statusvertrag und PacketPrivacy.
Kein Remotehost, alternativer Endpunkt oder automatischer Fallback.
2. V5 mit festem erwarteten LocalService-SID und lokal konstruiertem Descriptor,
dessen einzige Allow-ACE den echten `NT SERVICE\W32Time`-SID bezeichnet.
Account und Service-SID kommen niemals aus der Endpointantwort. Descriptor,
ACL und beide SIDs leben bis nach dem vollständigen RPC-Aufruf.
3. Derselbe Statusaufruf mit ausschließlich falschem erwartetem Account
(LocalSystem statt LocalService), korrektem W32Time-Descriptor.
4. Derselbe Statusaufruf mit korrektem Account, aber ausschließlich falschem
Service-SID (`RmmDiscoveryWindows` statt W32Time). Damit wird die Trennung
gegenüber dem ebenfalls als LocalService laufenden Network-Agent getestet.
Erforderlich wären echter positiver Return mit validem Status **und** zwei
nachvollziehbare Identitätsverweigerungen ohne gelieferten Status, unter
identischem frischem Dienst-/Boot-/Binarykontext. Timeout, fehlender Endpunkt,
ungültiger Stub oder derselbe 1783-Fehler auf allen Varianten sind unzureichend.
Eine akzeptierte falsche Identität falsifiziert den Kandidaten; keine Abschwächung
auf Account-only. Der tatsächlich aktivierte W32Time-Service-SID und die feste
Dienstkonfiguration müssen zuvor rein lesend belegt sein. Fehlende SID-Isolation
darf nicht durch eine Service-/Token-/ACL-Änderung für die Diagnose repariert
werden.
Die spätere Probe benötigt einen einzelnen begrenzten Diagnoseworker, feste
Varianten und numerische Stage-/Return-/Status-Presencefelder. Kein freier
SID-/Endpunktparameter, kein Ersatzthread nach hängendem Call und kein Retry
mit schwächerer Authentisierung. Erst diese technischen Diagnosen wären eine
Grundlage für eine separate Clockvertrauensentscheidung; sie öffnen weder
`ADAPTER_QUALIFIED` noch Jobcapabilities oder den SYSTEM-Helperpfad.