Document native Windows EEInfo probe and preserved closed gates
Rust development slice / linux (push) Failing after 6s
Rust development slice / linux (push) Failing after 6s
This commit is contained in:
@@ -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);
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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.
|
||||
@@ -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.
|
||||
Reference in New Issue
Block a user