Document native SPNEGO empty-principal diagnostic result
Rust development slice / linux (push) Failing after 6s

This commit is contained in:
2026-11-14 19:29:09 +01:00
parent 01f0a0476e
commit 98f4edfbff
5 changed files with 1127 additions and 0 deletions
@@ -0,0 +1,166 @@
#!/usr/bin/env python3
"""Local-only SPNEGO comparison: retain the returned non-NULL empty principal."""
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-spnego-empty-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'
PARENT_MANIFEST = ROOT / 'devstate/windows-clock-spnego-trace/build-2ebcfe9c-1e2b-4a50-99c5-3370640aeb77/manifest.json'
PARENT_SHA = 'f6b5cd23b1599c2db4fc803fd7232dfd3522dead840e492f659e4efd7a6be001'
PARENT_RESULT = ROOT / 'devstate/windows-clock-spnego-trace/0f512772-3599-4c83-b877-41c74fe50fb0/diagnostic-result.json'
PARENT_RESULT_SHA = '4c99b34b8c64f877dbbf0fe860d59499f1c054de7d036016e80b84581448cfc9'
UNCHANGED_DIAGNOSTICS = {
'deploy/windows/clock-system-trace/system_trace.c': '5be92130fda4dbb2a0078861f2b4ebd70bc3b7ecc3a65af0b426702cb69b772a',
'deploy/windows/clock-system-trace/build.py': 'e66ef17ba8a442f594114e3fa8eec62c256f0a9b1d9ca0d4e5c821675e00f05f',
'deploy/windows/clock-system-trace/native.py': 'fd46fc5167ac85808a4483f76e774e5e05e0d79f4a01def611a0c0b91414714e',
'deploy/windows/clock-eeinfo-trace/clock_rpc_eeinfo.c': '2bf009c3118af34ae7945c7d67b4647f0b24a9db34fbeeb4b44299e69f7e9a68',
'deploy/windows/clock-eeinfo-trace/system_trace_eeinfo.c': '09628d345592c767ebe136e40108e283e96bc37f749c5db93e62e327cb890301',
'deploy/windows/clock-eeinfo-trace/build.py': '59a0c3f881b824d921d165ace4da1e5992b85ddbf9d1d5132404b588dd50f36c',
'deploy/windows/clock-eeinfo-trace/native.py': 'cc71c230d4e6e30831eefd20de3d80848732e74d0ce077d79db29c3a1db33e8f',
'deploy/windows/clock-spnego-trace/clock_rpc_spnego.c': '10882bb39d7f27cc7e42123f2d2d4b2dbfb7a4cf86ed5bc80767c5fba1a33147',
'deploy/windows/clock-spnego-trace/system_trace_spnego.c': '74f96e1e3d55799c3b599abf81ad5e66e436b9fcbd3b7125d87fe102d303812c',
'deploy/windows/clock-spnego-trace/build.py': 'b10cdc0ba340d9b209e40a22391606f763aed01669e0356322f817eca6f08e0c',
'deploy/windows/clock-spnego-trace/native.py': 'b85773f8c65d99aa59ec7318a2edca38d205ad3da394f645220f63ba1914bfd0',
}
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(PARENT_MANIFEST) == PARENT_SHA and sha(PARENT_RESULT) == PARENT_RESULT_SHA, 'original F6 and empty-principal case retained')
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')
require(all(sha(ROOT/name)==digest for name,digest in UNCHANGED_DIAGNOSTICS.items()),'existing SYSTEM/WINNT/EEInfo diagnostic sources unchanged')
return value
def own_sources():
return {str((HERE / name).relative_to(ROOT)):sha(HERE / name) for name in ('clock_rpc_spnego_empty.c','system_trace_spnego_empty.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_spnego_empty.c'
write(source / 'clock_rpc.c', wrapper.read_bytes()); write(source / 'system_trace.c', (HERE / 'system_trace_spnego_empty.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_spnego_empty.c'))
write(folder / 'wrapper-source.diff',delta.encode())
parent_wrapper = ROOT / 'deploy/windows/clock-spnego-trace/clock_rpc_spnego.c'
parent_delta = ''.join(difflib.unified_diff(parent_wrapper.read_text().splitlines(True), wrapper.read_text().splitlines(True),
fromfile='unchanged-parent-spnego.c', tofile='new-spnego-empty.c'))
write(folder / 'parent-wrapper-source.diff', parent_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'), unchanged_diagnostics=UNCHANGED_DIAGNOSTICS,
parent_manifest_sha256=PARENT_SHA,parent_result_sha256=PARENT_RESULT_SHA,parent_wrapper_diff_sha256=sha(folder / 'parent-wrapper-source.diff'),
own_system_token_only=True,token_query_only=True,max_principal_discoveries=1,max_status_queries=1,principal_identity_proven=False,returned_empty_principal_allowed=True,null_principal_allowed=False,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/ClockSpnegoEmptyTrace.linked.exe'])
raw_linked = output / 'ClockSpnegoEmptyTrace.linked.exe'
linked = output / 'ClockSpnegoEmptyTrace.original.exe'; delivery = output / 'ClockSpnegoEmptyTrace.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/ClockSpnegoEmptyTrace.exe'])
imports = sorted(set(re.findall(r'DLL Name:\s+(\S+)',run('imports',['x86_64-w64-mingw32-objdump','-p','/out/ClockSpnegoEmptyTrace.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')
require(imports == json.loads(PARENT_MANIFEST.read_bytes())['artifact']['imports'], 'same DLL imports as exact F6 comparison')
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-spnego-empty-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,unchanged_diagnostics=UNCHANGED_DIAGNOSTICS,token_query_only=True,max_principal_discoveries=1,max_status_queries=1,principal_identity_proven=False,
parent_manifest_sha256=PARENT_SHA,parent_result_sha256=PARENT_RESULT_SHA,parent_wrapper_diff_sha256=sha(folder / 'parent-wrapper-source.diff'),returned_empty_principal_allowed=True,null_principal_allowed=False,
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,259 @@
/* Isolated diagnostic variant: discover SPNEGO principal on the fixed local
* authenticated endpoint, then at most one MS-W32T Opnum6. No fallback/trust.
* Actual Microsoft-generated MIDL is reused. SEH stays entirely inside C.
*/
#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);
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);
}
/* Numeric protocol-path observations, never a server-identity assertion. */
typedef struct {
uint32_t discovery_invocations, discovery_status, discovery_return_present;
uint32_t principal_present, principal_units, principal_validated;
uint32_t status_query_invocations, authn_service, authn_level, impersonation_type;
uint32_t principal_free_attempted, principal_free_status;
uint32_t binding_free_attempted, binding_free_status, eeinfo_origin;
} RmmClockAuthTrace;
_Static_assert(sizeof(RmmClockAuthTrace) == 60, "numeric SPNEGO path ABI");
static uint32_t check_principal(RPC_WSTR value, RmmClockAuthTrace *auth) {
if (!value) return ERROR_INVALID_DATA;
auth->principal_present = 1;
int high = 0;
for (unsigned i = 0; i <= 512; ++i) {
unsigned unit = value[i];
if (!unit) {
auth->principal_units = i;
/* Preserve a returned non-NULL empty string; the SSP decides its meaning. */
if (high) return ERROR_INVALID_NAME;
auth->principal_validated = 1;
return ERROR_SUCCESS;
}
if (i == 512 || unit < 0x20 || (unit >= 0x7f && unit <= 0x9f)) return ERROR_INVALID_NAME;
if (high) {
if (unit < 0xdc00 || unit > 0xdfff) return ERROR_INVALID_NAME;
high = 0;
} else if (unit >= 0xd800 && unit <= 0xdbff) high = 1;
else if (unit >= 0xdc00 && unit <= 0xdfff) return ERROR_INVALID_NAME;
}
return ERROR_INVALID_NAME;
}
static uint32_t invoke_status(RPC_BINDING_HANDLE binding, RmmClockStatus *out, RmmClockTrace *trace, RmmClockEeInfo *eeinfo, RmmClockAuthTrace *auth) {
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;
auth->status_query_invocations = 1;
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, RmmClockAuthTrace *auth) {
RPC_WSTR text = NULL;
RPC_BINDING_HANDLE binding = NULL;
RPC_WSTR principal = NULL;
RPC_SECURITY_QOS qos = {0};
unsigned long result;
memset(out, 0, sizeof(*out));
memset(auth, 0, sizeof(*auth));
auth->authn_service = RPC_C_AUTHN_GSS_NEGOTIATE;
auth->authn_level = RPC_C_AUTHN_LEVEL_PKT_PRIVACY;
auth->impersonation_type = RPC_C_IMP_LEVEL_IDENTIFY;
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;
/* Bound the management discovery as well as Opnum6. RpcMgmt allocates its
* returned string internally: the 512-unit check bounds inspection/use,
* not RPC runtime allocations made before the API returns. */
if (trace) trace->stage = 40;
result = RpcBindingSetOption(binding, RPC_C_OPT_CALL_TIMEOUT, 1500);
if (!result) {
if (trace) trace->stage = 25;
RpcTryExcept {
auth->discovery_invocations = 1;
result = RpcMgmtInqServerPrincNameW(binding, RPC_C_AUTHN_GSS_NEGOTIATE, &principal);
auth->discovery_return_present = 1;
auth->discovery_status = result;
if (result && eeinfo) {auth->eeinfo_origin = 1; capture_eeinfo(eeinfo);}
} RpcExcept(RpcExceptionFilter(RpcExceptionCode())) {
result = RpcExceptionCode();
auth->discovery_status = result;
if (eeinfo) {auth->eeinfo_origin = 1; capture_eeinfo(eeinfo);}
if (trace) {trace->stage = 91; trace->rpc_exception = result;}
} RpcEndExcept
}
if (!result) {
if (trace) trace->stage = 26;
result = check_principal(principal, auth);
}
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 (!result) {
if (trace) trace->stage = 30;
/* The returned principal is ONLY a diagnostic authentication input,
* never an independently trusted service/account/SID assertion. */
result = RpcBindingSetAuthInfoExW(binding, principal, RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
RPC_C_AUTHN_GSS_NEGOTIATE, NULL, RPC_C_AUTHZ_NONE, &qos);
if (result && eeinfo) {auth->eeinfo_origin = 3; capture_eeinfo(eeinfo);}
}
if (!result) {
result = invoke_status(binding, out, trace, eeinfo, auth);
if (eeinfo && eeinfo->capture_attempted) auth->eeinfo_origin = 2;
}
/* Preserve the original discovery/auth/query result before cleanup RPC. */
if (principal) {
auth->principal_free_attempted = 1;
auth->principal_free_status = RpcStringFreeW(&principal);
}
auth->binding_free_attempted = 1;
auth->binding_free_status = RpcBindingFree(&binding);
return result;
}
/* At most one authenticated status query after exactly one discovery. */
uint32_t rmm_clock_query_trace_spnego_empty(RmmClockTrace *trace, RmmClockEeInfo *eeinfo, RmmClockAuthTrace *auth) {
RmmClockStatus ignored = {0};
memset(trace, 0, sizeof(*trace));
memset(eeinfo, 0, sizeof(*eeinfo));
return pipe_query(&ignored, trace, eeinfo, auth);
}
@@ -0,0 +1,272 @@
#!/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-spnego-empty-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-spnego-empty-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='RmmClockSpnegoEmptyDiagnostic';$case=Join-Path $root ('clock-spnego-empty-trace-'+$id);$exe=Join-Path $case 'ClockSpnegoEmptyTrace.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='RmmClockSpnegoEmptyDiagnostic'" -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}
$token=$null;$tokenFile=Join-Path $case 'token.json';if(Test-Path -LiteralPath $tokenFile){$token=Get-RmmTraceJson $tokenFile}
$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;token_before_rpc=$token;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-spnego-empty-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')
require(value['token_query_only'] is True and value['max_principal_discoveries']==value['max_status_queries']==1
and value['principal_identity_proven'] is False,'no privilege mutation/fallback or principal-as-identity claim')
require(value['parent_manifest_sha256']=='f6b5cd23b1599c2db4fc803fd7232dfd3522dead840e492f659e4efd7a6be001'
and value['parent_result_sha256']=='4c99b34b8c64f877dbbf0fe860d59499f1c054de7d036016e80b84581448cfc9'
and value['returned_empty_principal_allowed'] is True and value['null_principal_allowed'] is False
and sha(path.parent/'parent-wrapper-source.diff')==value['parent_wrapper_diff_sha256'],
'exact F6 comparison, returned non-NULL string only; no fabricated target or fallback')
for name,digest in value['unchanged_diagnostics'].items():require(sha(ROOT/name)==digest,'original SYSTEM/WINNT/EEInfo inputs retained')
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-spnego-empty-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 type(report['query_invocations']) is int and report['query_invocations'] in (0,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')
token=report['token']
require(set(token)=={'query_status','system_user','token_type','thread_query_status','thread_present','lookup_status','privileges_status','privilege_present','privilege_attributes','privilege_enabled','privilege_default','privilege_removed'}
and all(type(v) is int and 0<=v<2**32 for v in token.values())
and token==value['token_before_rpc'] and token['query_status']==token['lookup_status']==token['privileges_status']==0
and token['system_user']==1 and token['token_type']==1 and token['thread_present']==0 and token['thread_query_status']==1008,
'durable own SYSTEM primary token/privileges observed before RPC without impersonation')
require(all(token[k] in (0,1) for k in ('privilege_present','privilege_enabled','privilege_default','privilege_removed'))
and token['privilege_enabled']==int(bool(token['privilege_attributes']&2))
and token['privilege_default']==int(bool(token['privilege_attributes']&1))
and token['privilege_removed']==int(bool(token['privilege_attributes']&4))
and (token['privilege_present'] or token['privilege_attributes']==0),'present/enabled privilege attributes remain observations only')
auth=report['auth']
require(set(auth)=={'discovery_invocations','discovery_status','discovery_return_present','principal_present','principal_units','principal_validated','status_query_invocations','authn_service','authn_level','impersonation_type','principal_free_attempted','principal_free_status','binding_free_attempted','binding_free_status','eeinfo_origin'}
and all(type(v) is int and 0<=v<2**32 for v in auth.values())
and auth['authn_service']==9 and auth['authn_level']==6 and auth['impersonation_type']==2
and all(auth[k] in (0,1) for k in ('discovery_invocations','discovery_return_present','principal_present','principal_validated','status_query_invocations','principal_free_attempted','binding_free_attempted'))
and auth['status_query_invocations']==report['query_invocations'] and auth['eeinfo_origin'] in (0,1,2,3)
and auth['discovery_return_present']<=auth['discovery_invocations']
and auth['principal_units']<=512,'bounded one-discovery/at-most-one-status SPNEGO Privacy Identify path')
if auth['principal_validated']:
require(auth['principal_present']==1 and 0<=auth['principal_units']<=512,'checked non-NULL bounded UTF16 principal, possibly empty')
if auth['principal_present']:
require(auth['principal_free_attempted']==1,'owned principal cleanup attempted')
if auth['status_query_invocations']:
require(auth['discovery_invocations']==auth['discovery_return_present']==auth['principal_present']==auth['principal_validated']==1
and auth['discovery_status']==0 and 0<=auth['principal_units']<=512,'no status query without successful checked principal discovery')
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')
require(ee['capture_attempted']==int(auth['eeinfo_origin']!=0),'numeric EEInfo origin matches capture')
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'] in (90,91):
require(ee['capture_attempted']==1 and report['rpc_code']==report['trace']['rpc_exception']
and auth['eeinfo_origin']==(2 if report['trace']['stage']==90 else 1),'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-spnego-empty-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-spnego-empty-trace-'+ident+'/ClockSpnegoEmptyTrace.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,233 @@
/* Isolated SPNEGO diagnostic. Original MIDL remains unchanged. Read the own
* SYSTEM token first; one management discovery, then at most one status query.
* No clock setter, token impersonation, NTP/ACL/provider or product gate. */
#define _WIN32_WINNT 0x0a00
#define UNICODE 1
#include <windows.h>
#include <stdint.h>
#include <stddef.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");
typedef struct {
uint32_t discovery_invocations, discovery_status, discovery_return_present;
uint32_t principal_present, principal_units, principal_validated;
uint32_t status_query_invocations, authn_service, authn_level, impersonation_type;
uint32_t principal_free_attempted, principal_free_status;
uint32_t binding_free_attempted, binding_free_status, eeinfo_origin;
} RmmClockAuthTrace;
_Static_assert(sizeof(RmmClockAuthTrace) == 60, "same numeric auth trace ABI");
typedef struct {
uint32_t query_status, system_user, token_type, thread_query_status, thread_present;
uint32_t lookup_status, privileges_status, privilege_present, privilege_attributes;
uint32_t privilege_enabled, privilege_default, privilege_removed;
} RmmTokenProbe;
uint32_t rmm_clock_query_trace_spnego_empty(RmmClockTrace *trace, RmmClockEeInfo *eeinfo, RmmClockAuthTrace *auth);
static WCHAR service_name[] = L"RmmClockSpnegoEmptyDiagnostic";
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(RmmTokenProbe *probe) {
HANDLE token = NULL;
HANDLE thread = NULL;
DWORD needed = 0, result = ERROR_SUCCESS;
_Alignas(8) BYTE storage[4096];
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &token)) {
probe->query_status = GetLastError();
return probe->query_status;
}
if (!GetTokenInformation(token, TokenUser, storage, sizeof(storage), &needed)) result = GetLastError();
else if (needed < sizeof(TOKEN_USER) || needed > sizeof(storage)
|| !IsWellKnownSid(((TOKEN_USER *)storage)->User.Sid, WinLocalSystemSid)) result = ERROR_ACCESS_DENIED;
else probe->system_user = 1;
if (!result) {
TOKEN_TYPE type = 0;
if (!GetTokenInformation(token, TokenType, &type, sizeof(type), &needed)) result = GetLastError();
else {
probe->token_type = (uint32_t)type;
if (needed != sizeof(type) || type != TokenPrimary) result = ERROR_ACCESS_DENIED;
}
}
if (!result) {
if (OpenThreadToken(GetCurrentThread(), TOKEN_QUERY, TRUE, &thread)) {
probe->thread_present = 1;
CloseHandle(thread);
result = ERROR_ACCESS_DENIED; /* never impersonate/revert to continue */
} else {
probe->thread_query_status = GetLastError();
if (probe->thread_query_status != ERROR_NO_TOKEN) result = probe->thread_query_status;
}
}
if (!result) {
LUID target = {0};
if (!LookupPrivilegeValueW(NULL, SE_SYSTEMTIME_NAME, &target)) {
probe->lookup_status = GetLastError();result = probe->lookup_status;
} else {
needed = 0;
if (GetTokenInformation(token, TokenPrivileges, NULL, 0, &needed)
|| GetLastError() != ERROR_INSUFFICIENT_BUFFER || needed < sizeof(DWORD) || needed > sizeof(storage)) {
probe->privileges_status = ERROR_INVALID_DATA;result = ERROR_INVALID_DATA;
} else if (!GetTokenInformation(token, TokenPrivileges, storage, sizeof(storage), &needed)) {
probe->privileges_status = GetLastError();result = probe->privileges_status;
} else {
TOKEN_PRIVILEGES *privileges = (TOKEN_PRIVILEGES *)storage;
size_t count = privileges->PrivilegeCount;
if (count > 256 || needed > sizeof(storage)
|| offsetof(TOKEN_PRIVILEGES, Privileges) + count * sizeof(LUID_AND_ATTRIBUTES) > needed) {
probe->privileges_status = ERROR_INVALID_DATA;result = ERROR_INVALID_DATA;
} else for (size_t i = 0; i < count; ++i) {
const LUID_AND_ATTRIBUTES *p = &privileges->Privileges[i];
if (p->Luid.LowPart != target.LowPart || p->Luid.HighPart != target.HighPart) continue;
if (probe->privilege_present) {result = ERROR_INVALID_DATA;break;}
probe->privilege_present = 1;
probe->privilege_attributes = p->Attributes;
probe->privilege_enabled = !!(p->Attributes & SE_PRIVILEGE_ENABLED);
probe->privilege_default = !!(p->Attributes & SE_PRIVILEGE_ENABLED_BY_DEFAULT);
probe->privilege_removed = !!(p->Attributes & SE_PRIVILEGE_REMOVED);
}
}
}
}
probe->query_status = result;
CloseHandle(token);
return result;
}
#define TOKEN_FIELDS "\"query_status\":%lu,\"system_user\":%lu,\"token_type\":%lu,\"thread_query_status\":%lu,\"thread_present\":%lu,\"lookup_status\":%lu,\"privileges_status\":%lu,\"privilege_present\":%lu,\"privilege_attributes\":%lu,\"privilege_enabled\":%lu,\"privilege_default\":%lu,\"privilege_removed\":%lu"
#define TOKEN_VALUES(p) (unsigned long)(p)->query_status,(unsigned long)(p)->system_user,(unsigned long)(p)->token_type,(unsigned long)(p)->thread_query_status,(unsigned long)(p)->thread_present,(unsigned long)(p)->lookup_status,(unsigned long)(p)->privileges_status,(unsigned long)(p)->privilege_present,(unsigned long)(p)->privilege_attributes,(unsigned long)(p)->privilege_enabled,(unsigned long)(p)->privilege_default,(unsigned long)(p)->privilege_removed
static DWORD write_new(const WCHAR *suffix, const char *bytes, DWORD length) {
WCHAR path[256];DWORD written = 0, result = ERROR_SUCCESS;
int count = swprintf(path, sizeof(path) / sizeof(path[0]),
L"C:\\ProgramData\\RustDiscoveryBootstrap\\clock-spnego-empty-trace-%ls\\%ls", case_id, suffix);
if (count <= 0 || count >= (int)(sizeof(path) / sizeof(path[0]))) return ERROR_INVALID_PARAMETER;
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, bytes, length, &written, NULL) || written != length) result = ERROR_WRITE_FAULT;
else if (!FlushFileBuffers(file)) result = GetLastError();
CloseHandle(file);return result;
}
static DWORD write_token(const RmmTokenProbe *token) {
char report[1024];
int count = snprintf(report, sizeof(report), "{" TOKEN_FIELDS "}\n", TOKEN_VALUES(token));
if (count <= 0 || count >= (int)sizeof(report)) return ERROR_BUFFER_OVERFLOW;
return write_new(L"token.json", report, (DWORD)count);
}
static DWORD write_result(uint32_t rpc, const RmmClockTrace *trace, const RmmClockEeInfo *eeinfo, const RmmClockAuthTrace *auth, const RmmTokenProbe *token) {
char id[37], report[4096];
for (unsigned i = 0; i < 37; ++i) id[i] = (char)case_id[i];
int count = snprintf(report, sizeof(report),
"{\"schema_version\":1,\"profile\":\"clock-system-spnego-empty-v1\",\"case_id\":\"%s\","
"\"token_system\":true,\"read_only\":true,\"diagnostic_only\":true,\"query_invocations\":%lu,"
"\"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)auth->status_query_invocations, (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,
"]},\"token\":{" TOKEN_FIELDS "},\"auth\":{"
"\"discovery_invocations\":%lu,\"discovery_status\":%lu,\"discovery_return_present\":%lu,"
"\"principal_present\":%lu,\"principal_units\":%lu,\"principal_validated\":%lu,"
"\"status_query_invocations\":%lu,\"authn_service\":%lu,\"authn_level\":%lu,\"impersonation_type\":%lu,"
"\"principal_free_attempted\":%lu,\"principal_free_status\":%lu,\"binding_free_attempted\":%lu,"
"\"binding_free_status\":%lu,\"eeinfo_origin\":%lu}}\n",
TOKEN_VALUES(token), (unsigned long)auth->discovery_invocations, (unsigned long)auth->discovery_status,
(unsigned long)auth->discovery_return_present, (unsigned long)auth->principal_present,
(unsigned long)auth->principal_units, (unsigned long)auth->principal_validated,
(unsigned long)auth->status_query_invocations, (unsigned long)auth->authn_service,
(unsigned long)auth->authn_level, (unsigned long)auth->impersonation_type,
(unsigned long)auth->principal_free_attempted, (unsigned long)auth->principal_free_status,
(unsigned long)auth->binding_free_attempted, (unsigned long)auth->binding_free_status,
(unsigned long)auth->eeinfo_origin);
if (appended <= 0 || (size_t)appended >= sizeof(report) - used) return ERROR_BUFFER_OVERFLOW;
used += (size_t)appended;
count = (int)used;
return write_new(L"result.json", report, (DWORD)count);
}
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;
RmmTokenProbe token = {0};
DWORD result = own_system_token(&token);
DWORD token_write = write_token(&token); /* durable numeric witness before RPC */
if (!result) result = token_write;
if (!result) {
RmmClockTrace trace = {0};
RmmClockEeInfo eeinfo = {0};
RmmClockAuthTrace auth = {0};
uint32_t rpc = rmm_clock_query_trace_spnego_empty(&trace, &eeinfo, &auth);
result = write_result(rpc, &trace, &eeinfo, &auth, &token);
}
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;
}
+197
View File
@@ -0,0 +1,197 @@
# Isolierter Vergleich mit tatsächlich zurückgegebenem leerem Principal
Stand2026-11-14: neuer getrennter Diagnosenachfolger lokal gebaut/geprüft.
**Native Ausführung, separater Readback und Cleanup durch den Hauptagenten inzwischen erfolgt; der Subagent hat keine VM-/SSH-Aktion ausgeführt.**
Produktcode, Clockgate, ursprüngliche131Quellen sowie WINNT-/SYSTEM-/EEInfo- und
F6-SPNEGO-Proben bleiben unverändert und mit ihren ursprünglichen Treibern lesbar.
## Tatsächlicher Ausgangsbefund
Der ursprüngliche SPNEGO-Case
`0f512772-3599-4c83-b877-41c74fe50fb0` verwendet Manifest
`f6b5cd23b1599c2db4fc803fd7232dfd3522dead840e492f659e4efd7a6be001`.
Sein unveränderter `diagnostic-result.json` hat SHA256
`4c99b34b8c64f877dbbf0fe860d59499f1c054de7d036016e80b84581448cfc9`.
Der tatsächliche Bericht meldet Discovery1/Status0/normaler Return1,
Principalpointer vorhanden1 und UTF16-Länge0. Die eigene Nichtleerprüfung
verweigert dies mit123/Stage26, vor dem Authsetup und vor Opnum6; Statusaufrufe0.
Das ist kein Nachweis eines W32Time-Statusqueryfehlers.
Die eigene SYSTEM-Primärtokenprobe wurde vorher erhalten: kein Threadtoken,
SeSystemtimePrivilege vorhanden1, Attribute0, Enabled0. Das bleibt eine reine
Beobachtung; weder daraus noch aus dem Leerstring werden Workgroup-, Domain-,
Provider-, ACL- oder Privilegursachen abgeleitet. Readback und Cleanup des alten
Cases erfolgen ausschließlich durch den Hauptagenten mit dessen originalem
Treiber; dieser Nachfolger ersetzt keinen historischen Beleg.
## Primärquellen und Schlussgrenze
Die Microsoft-API beschreibt den zurückgegebenen Principal als vom RPC-Runtime
allokierte Zeichenfolge, die anschließend mit RpcStringFree freizugeben ist.
Eine zusätzliche Mindestlänge wird dort nicht festgelegt.
[RpcMgmtInqServerPrincNameW](https://learn.microsoft.com/en-us/windows/win32/api/rpcdce/nf-rpcdce-rpcmgmtinqserverprincnamew)
Die Syntax und Bedeutung des Authentifizierungs-Zielnamens bestimmt der
verwendete SSP. Das ist keine allgemeine Garantie, dass jeder SSP einen leeren
Namen akzeptiert.
[RpcBindingSetAuthInfoExW](https://learn.microsoft.com/en-us/windows/win32/api/rpcdce/nf-rpcdce-rpcbindingsetauthinfoexw)
Microsoft nennt Systemdienste, für die manche Provider keinen Principalnamen
führen, und warnt ausdrücklich vor Principaldiscovery als sicherem
Serveridentitätsnachweis. Ein erfolgreicher Discoveryaufruf oder ein weiter
gelungener Statusaufruf beweist hier deshalb keine unabhängig gepinnte
Serveridentität.
[Principal Names](https://learn.microsoft.com/en-us/windows/win32/rpc/principal-names)
MS-W32T AppendixB Fußnote16 beschreibt erfolgreiche Managementdiscovery und
danach den tatsächlich gelieferten Namen mit SPNEGO/PacketPrivacy. Sie fügt
keine Nichtleerbedingung hinzu. Die dort ebenfalls beschriebene unauthentisierte
Fallbackvariante wird hier ausdrücklich nicht implementiert. Fußnote33 beschreibt
eine zusätzliche Privilegprüfung aller authentisierten Methoden; sie erklärt
weder den jetzigen eigenen Stage26-Abbruch noch allein die Bedeutung von
Present/Enabled in unserem Tokenbefund.
[MS-W32T Appendix B, Fußnoten16/33](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-w32t/bb576d39-587b-484a-86a4-e1d378cf9497)
Der engere Schluss ist daher lediglich eine begründete **Diagnosehypothese**:
die eigene Nichtleer-Zusatzprüfung einmal isoliert entfernen und die exakte
Runtimeantwort an den unveränderten SSP übergeben. Es wurde keine konkrete
Primärquellenpflicht gefunden, die genau diesen Diagnosevergleich verbietet.
Es wird weder universelle Leerstring-Zulässigkeit noch Produktionsfähigkeit
behauptet.
## Exakter neuer Scope
Vier neue Dateien unter `deploy/windows/clock-spnego-empty-trace/`:
- `clock_rpc_spnego_empty.c`: im vorhandenen UTF16-Prüfer entfällt allein das
`!i`-Verbot am terminierenden Nullzeichen. NULL-Pointer bleiben Fehler,
Hoch-/Niedrigsurrogate, Steuerzeichen und die512-Unit-Grenze bleiben geprüft.
Der tatsächlich von RpcMgmt gelieferte Pointer wird unverändert und nicht-NULL
an RpcBindingSetAuthInfoExW weitergereicht, auch wenn er auf eine leere
terminierte Zeichenfolge zeigt. Kein erfundener SPN und keine NULL-Ersetzung.
- `system_trace_spnego_empty.c`: gleiches Token-/RPC-/EEInfo-Verhalten;
ausschließlich getrennte Symbol-, Service-, Profil- und Casepfadnamen.
`own_system_token` ist byteidentisch zum Original.
- `native.py`: eigene Case-/Manifest-/Servicebindung; Ergebnisprüfung erlaubt
nun0..512Units nur bei weiterhin vorhandenem und geprüftem Principal.
Ohne erfolgreiche einzelne Discovery kein Statusaufruf.
- `build.py`: gleicher lokaler Compiler-/MIDL-/SDKpfad; bindet zusätzlich
unverändertes F6, dessen beobachteten Ausgangscase und alle vier alten
SPNEGO-Quellen. Der kleine direkte Eltern-Wrapperdiff wird separat erhalten.
Eigenes SCM-Serviceobjekt: `RmmClockSpnegoEmptyDiagnostic`; eigenes Profil:
`clock-system-spnego-empty-v1`; eigener Pfad:
`C:\ProgramData\RustDiscoveryBootstrap\clock-spnego-empty-trace-<UUID>`.
Originale Services/Cases werden weder adressiert noch ersetzt.
Unverändert bleiben GSS_NEGOTIATE9, PacketPrivacy6, Identify2, genau eine
Managementdiscovery und höchstens ein Opnum6 auf dem bereits bekannten
authentisierten W32TIME_ALT-Pfad. Fehler führen weder zu anderem SSP noch zu
anonymer oder unauthentisierter Wiederholung. Das unveränderte AuthIdentity-NULL
bedeutet die bestehende eigene Prozessidentität, keine neu gewählte anonyme
Identität. Die Principal-Pointer-Unterscheidung wird davon getrennt behandelt.
Maximal vier ausschließlich numerische EEInfo-Records, unmittelbare Aufnahme
vor weiterem RPC/Cleanup, keine Namen oder Parameterinhalte.
Vor RPC werden ausschließlich das eigene SYSTEM-Token und dessen vorhandene
Privileginformationen gelesen und als numerischer Beleg create-once geschrieben.
Kein AdjustTokenPrivileges, kein Impersonate, keine Uhr-, ACL-, Policy-, NTP-,
W32Time- oder RMM-Änderung. Ein temporärer Diagnoseservice ist ausschließlich
separate explizite Bootstrapwirkung des späteren Hauptagenten, kein RMM-Job.
Readback bleibt rein lesend; Cleanup ist ein separater expliziter Vorgang nur
für den gebundenen eigenen gestoppten Service. Nach Antwortverlust kein Startretry.
## Tatsächlicher lokaler Build
Buildcase:
`devstate/windows-clock-spnego-empty-trace/build-9daffc05-64d1-45c2-954a-4ec642c5ef70`.
Manifest-SHA256:
`768293c37702e40876a83bbab4a24186a3b4e284cf9a193c40550dd72ef32548`.
Windows-x64-PE `ClockSpnegoEmptyTrace.exe`:99727Bytes, SHA256
`7ca7cd51cc84678068f00d9ae5344a76485db6a600557757f925f6fcb3228fe5`.
Verwendet wurde dasselbe gepinnte Image1b2fd985… und die ursprüngliche
Microsoft-MIDL-Ausgabe aus149bafe2 mit Headerhashdb5dbe5b… und Stubhashd806adb4….
Keine Codegenerierung mit WIDL, kein Header- oder OUT_DIR-Patch. Beide eigenen
C-Units wurden mit Wall/Wextra/Werror übersetzt. Für die unveränderte tatsächliche
MIDL-Unit bleiben genau die bereits überprüften zwei sichtbaren Warnklassen
ohne Werror-Eskalation erhalten. Link, Strip, Importprüfung und echter
PowerShell-AST-Parse erfolgreich. EncodedCommand17146Zeichen, unter32767.
Die DLL-Importliste stimmt **exakt** mit F6 überein:
ADVAPI32.dll, KERNEL32.dll, RPCRT4.dll und msvcrt.dll. Alle131Originaldateien und
die elf bisherigen Diagnosequellen blieben beim Build byteidentisch; das
ursprüngliche F6-Manifest und sein Ergebnisbeleg sind zusätzlich gehasht gebunden.
Vorhandene Primärunterlagen-Snapshots wurden nicht verändert.
Der tatsächliche neue C-Prüfer wurde außerdem lokal mit einem temporären
uint16-Fixturetreiber ausgeführt: zehn Fälle einschließlich NULL, nicht-NULL
Leerstring, gültiger Surrogatfolge, ungültiger Unicode-/Steuerzeichen und
512/513Grenze bestanden. Die echte Python-Ergebnisprüfung wurde mit synthetischem
Empty-Query-Bericht geprüft und verweigerte neun Änderungen an Pointer-/Valid-
Status, Länge, Discovery-/Queryzahl, Authparametern und Tokenbefund. Das erzeugt
keinen Windows-RPC-Nachweis. Beleg `empty-local-guards.json`, SHA256
`9d276e59c3376be3e47cc2580238904ac76bfeda08e4665b2edd5ff39011362a`.
## Geplante native Fortsetzung, nicht ausgeführt
Erst nach unabhängigem Rootreview dieses Source-/Manifeststands:
```text
python3 deploy/windows/clock-spnego-empty-trace/native.py prepare --manifest ABSOLUTE_NEW_MANIFEST --access-root /home/kevin/Schreibtisch/Coding/rust-discovery --execute-native
python3 deploy/windows/clock-spnego-empty-trace/native.py start --manifest ABSOLUTE_NEW_MANIFEST --access-root /home/kevin/Schreibtisch/Coding/rust-discovery --id NEW_CASE --execute-native
python3 deploy/windows/clock-spnego-empty-trace/native.py readback --manifest ABSOLUTE_NEW_MANIFEST --access-root /home/kevin/Schreibtisch/Coding/rust-discovery --id NEW_CASE
python3 deploy/windows/clock-spnego-empty-trace/native.py cleanup --manifest ABSOLUTE_NEW_MANIFEST --access-root /home/kevin/Schreibtisch/Coding/rust-discovery --id NEW_CASE --execute-native
```
Der ursprüngliche0f512772-Case bleibt beim alten F6-Treiber. Der neue Vergleich
beansprucht weder Clock-/Adapterqualifikation noch Serveridentitätsnachweis,
Produktgate, Signier-/Jobrecht oder eine tatsächliche native Messung. Auch ein
eventueller RPC-Return0 wäre erst ein Diagnoseergebnis; die vollständige
Zeitvertrags- und Sicherheitsabnahme bliebe gesondert erforderlich.
## Tatsächlicher nativer Emptyvergleich 2026-11-14
Der Hauptagent hat ausschließlich den neuen Case
`5e0e8ce9-b9a3-4c4a-b739-3f84d714dc94` mit obigem unverändertem
Manifest768293c3… nativ ausgeführt. Der erhaltene Ergebnisbeleg
`diagnostic-result.json` hat SHA256
`c53378d5b6e1099a781bb007e2480609e4105b94498ce443df937a0a591ff307`.
Discovery1/Status0/Return1 liefert tatsächlich weiterhin einen nicht-NULL
Principal mit0UTF16-Units. Dieser wird unverändert akzeptiert und weitergegeben.
Danach wird genau eine Opnum6-Statusquery versucht. Ergebnis: RPCexception5,
Stage90, kein normaler RPCreturn und kein Statusobjekt. Der unmittelbar erfasste
numerische EEInfo-Befund enthält genau einen Record: Komponente2, Status5,
DetectionLocation1750, Flags0, Parameteranzahl1; Parameterinhalte werden nicht
gelesen. Eigenes SYSTEM-Primärtoken: Recht vorhanden1, Attribute0/Enabled0,
kein Threadtoken. Daraus folgt keine nachgewiesene Privileg-/ACL-/Providerursache.
Separater rein lesender Readback
`readback-03d099ce-a024-49c7-8a80-6c30f0228756.json`, SHA256
`7751477d29844f6f8b1e90f8c7322473014c631323aa5d88c54773445eb5f7ea`,
bestätigt den gleichen Bericht, den eigenen gestoppten Dienst und Exit0.
Exit0 bezeichnet den abgeschlossenen Diagnosebericht, keinen erfolgreichen
W32Time-Statusquery. Anschließend hat der Hauptagent den eigenen gestoppten
Diagnosedienst getrennt bereinigt. Cleanupreceipt
`readback-8786048c-06a9-43f1-bede-b62a1ef21e22.json`, SHA256
`1eb2fdef2aef832973897bd4bb6c01f459ab30e544c603e6feb81e1a318b3bb1`,
meldet cleanup_verified=true und already_absent=false.
Readback und eigenes Cleanup sind damit nachgewiesen. Nach dem separaten
ScopeClose hat der Hauptagent auch den After-Preservationvergleich gewonnen:
`rust-discovery-windows-pipe-drain/devstate/windows-client/system-pipe-upgrade/14fb176a-f653-4573-a8d7-6f9fe47a3020/spnego-empty-trace-after.json`, SHA256
`a8ab4396c1c8ed4fa2f0f3b06434efb0ecb058865c69aeba278744a850dd910f`.
Alle sechs nativen Bereiche `service`, `helper_service`, `agent_kernel`,
`helper_kernel`, `files` und `helper_witness` sind exakt zum Before unverändert.
Serverflags bleiben gleich, Rootpolicycf15 geschlossen, Hooksfalse; die
Windows-spezifischen Job-/Outbox-/Permit-/Unresolved-Zähler bleiben0/0/0/0.
Die global beobachteten Linux-Serverzähler sind ausdrücklich nicht unverändert:
30/30/26 wurden31/31/27, weiterhin unresolved0. Der Hauptagent belegt dies durch
den parallel tatsächlich über MCP beantragten und in der WebUI genehmigten
Linux-Fullscript-Caseced97b4d mit bestandenem Ergebnisbeleg89dcb583….
Diese autorisierte parallele Wirkung wird nicht als Wirkung der Emptyprobe oder
als globale Preservationgleichheit dargestellt. Der Empty-Abnahmeschritt ist als
Diagnose abgeschlossen; sein Ergebnis bleibt RPC5. Clock-/Adapterqualifikation,
Serveridentität und Produktgate bleiben nicht nachgewiesen/geschlossen.