diff --git a/deploy/windows/clock-system-trace/build.py b/deploy/windows/clock-system-trace/build.py new file mode 100644 index 0000000..38a4f5f --- /dev/null +++ b/deploy/windows/clock-system-trace/build.py @@ -0,0 +1,133 @@ +#!/usr/bin/env python3 +"""Local-only SYSTEM trace diagnostic build; no VM and no product source edits.""" +import base64 +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-system-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 ('system_trace.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 + wrapper = ROOT / 'crates/agent-windows/native/clock_rpc.c' + write(source / 'clock_rpc.c', wrapper.read_bytes()); write(source / 'system_trace.c', (HERE / 'system_trace.c').read_bytes()) + 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), 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/ClockSystemTrace.linked.exe']) + raw_linked = output / 'ClockSystemTrace.linked.exe' + linked = output / 'ClockSystemTrace.original.exe'; delivery = output / 'ClockSystemTrace.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/ClockSystemTrace.exe']) + imports = sorted(set(re.findall(r'DLL Name:\s+(\S+)',run('imports',['x86_64-w64-mingw32-objdump','-p','/out/ClockSystemTrace.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-trace-v1',image=IMAGE,baseline_sha256=BASELINE_SHA, + original131=baseline['source_files'],own_sources=before,wrapper_sha256=sha(wrapper),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 diff --git a/deploy/windows/clock-system-trace/native.py b/deploy/windows/clock-system-trace/native.py new file mode 100644 index 0000000..0d7c667 --- /dev/null +++ b/deploy/windows/clock-system-trace/native.py @@ -0,0 +1,222 @@ +#!/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-system-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-trace-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='RmmClockSystemDiagnostic';$case=Join-Path $root ('clock-system-trace-'+$id);$exe=Join-Path $case 'ClockSystemTrace.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='RmmClockSystemDiagnostic'" -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-trace-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') + 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-trace-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') + 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-trace-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-system-trace-'+ident+'/ClockSystemTrace.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,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 diff --git a/deploy/windows/clock-system-trace/system_trace.c b/deploy/windows/clock-system-trace/system_trace.c new file mode 100644 index 0000000..28654df --- /dev/null +++ b/deploy/windows/clock-system-trace/system_trace.c @@ -0,0 +1,99 @@ +/* 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 +#include +#include +#include + +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"); +uint32_t rmm_clock_query_trace(RmmClockTrace *trace); + +static WCHAR service_name[] = L"RmmClockSystemDiagnostic"; +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) { + WCHAR path[256]; + char id[37], report[1536]; + 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-system-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-trace-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; + 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}; + uint32_t rpc = rmm_clock_query_trace(&trace); /* exactly one fixed call */ + result = write_result(rpc, &trace); + } + 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; +} diff --git a/docs/windows-clock-system-trace.md b/docs/windows-clock-system-trace.md new file mode 100644 index 0000000..a2df8a8 --- /dev/null +++ b/docs/windows-clock-system-trace.md @@ -0,0 +1,142 @@ +# Getrennter SYSTEM-Vergleich für die W32Time-RPC-Diagnose + +Stand 2026-11-14: **implementiert und lokal gebaut, nicht auf der VM ausgeführt**. +Der User-/Orchestratorauftrag erlaubt hier ausschließlich einen neuen separaten +SID18-Diagnosedienst mit genau einem lesenden Traceaufruf. Bestehende Readiness, +RPC-/Clock-Produktquellen und sämtliche131 bisherigen Buildinputs bleiben +unverändert. Keine Produktgate-/Policy-/Konto-/NTP-/W32Time-ACLänderung. + +Ausgangsbefund ist der tatsächlich ausgeführte LocalService-MIDL-Diagnosefall +`94562d81-f75f-45c8-ab6b-28b70d12bd81`: Named Pipe meldete RPC5/Stage90 ohne +Status, ALPC weiterhin1753. Der Unterschied zu früher1783 ist kein positiver +Status-/Clocknachweis. Microsoft beschreibt unterschiedliche Netzwerkidentitäten +für [LocalService](https://learn.microsoft.com/en-us/windows/win32/services/localservice-account) +und [LocalSystem](https://learn.microsoft.com/en-us/windows/win32/services/localsystem-account). +Dies begründet den Vergleich, beweist aber keine konkrete Ursache. Auch ein +abweichendes SYSTEM-Ergebnis unterscheidet für sich weder SSPI-Credentials von +serverseitiger Token-/ACLautorisierung noch schließt es alle Harnessunterschiede +aus. Der ALPC-Endpunktbefund bleibt eine eigene offene Frage. + +## Enger neuer Quellschnitt + +Nur neue Dateien unter `deploy/windows/clock-system-trace/`: + +- `system_trace.c`: eigenständige einmalige SCM-Servicehülle + `RmmClockSystemDiagnostic`; prüft den tatsächlichen eigenen Prozesstoken mit + `OpenProcessToken`/`GetTokenInformation`/`IsWellKnownSid` auf SYSTEM und ruft + danach exakt einmal `rmm_clock_query_trace` auf. Kein Tokenwechsel und keine + Impersonation. Numerische RPC-/Tracefelder, feste Booleans und Fall-ID; + Ausgabedatei create-only, begrenzt und dauerhaft geflusht. +- `build.py`: eigenständiger Offline-C-Build mit originalem `clock_rpc.c` und + exakt denselben tatsächlich von Microsoft-MIDL erzeugten Header-/Stubbytes + aus Fall `149bafe2-3469-4580-b133-988812bcc3db`. Keine NDR-/Headerbearbeitung, + kein WIDL-Fallback und kein Patch im alten Build-/OUT_DIR. +- `native.py`: Root-Orchestrator mit getrennten expliziten Phasen `prepare`, + `start`, `readback`, `cleanup`. Vor Start dauerhaftes einmaliges Intent; + verlorener Reply erlaubt nur ursprüngliches Readback. Remote-Readback liest + ausschließlich, ändert weder ACLs noch Servicezustand und bereinigt nichts. + Cleanup darf ausschließlich den eindeutig gebundenen **gestoppten eigenen** + Diagnosedienst löschen. Alle Dateien/Originalbelege bleiben erhalten. + +Die vorhandene ReadinessEXE verweigert SYSTEM weiterhin absichtlich; sie wird +weder verändert noch als Launcher eingesetzt. C-Wrapper, Named-Pipe-Endpunkt, +WINNT/PacketPrivacy und QoS bleiben identisch zur bisherigen Diagnose. Das +Programm bewertet keinen Clockstatus und setzt `clock_qualified=false`, +`adapter_qualified=false`, `product_gate_open=false` auch bei RPC0. + +## Tatsächlich lokale Prüfungen + +```text +python3 deploy/windows/clock-system-trace/build.py +``` + +Gepinntes Image `sha256:1b2fd985d2c1fcc3545ace602405dc68fa899201bd8a73fa319ff96377203fa9`, +Netzwerk deaktiviert, Quellsnapshot nur lesbar, eigenes Ausgabe-/Belegverzeichnis. +Neue C-Hülle und unveränderter Wrapper bestanden Clang `-Wall -Wextra -Werror`. +Für den unveränderten generierten MIDL-Stub bleiben nur dieselben drei bekannten +Stilwarnungen sichtbar: fehlende Initialisierungsbrace und zwei unbenutzte +Konstanten; keine Typ-/Securitywarnung wurde abgeschaltet. MinGW-GCC-Link, +PE-x64-/Größen-/Importprüfung und tatsächlicher PowerShell-AST-Lauf bestanden. +Der fertige EncodedCommand umfasst16666Zeichen und liegt unter32767. + +Aktueller Manifest: +`devstate/windows-clock-system-trace/build-8b5fc22c-3dbe-4924-a431-9e889d6a4b7c/manifest.json`, +SHA256 `3b2c397eec9f3aa4a1e82ba10f2812f986c9b7e69e235c8f105ebaec221eaf5e`. +Standalone-PE98028Bytes, SHA256 +`0035fee43333b7cb8d34e70b9c53b31dae49e4793abb0f1e00271572c75b7922`. +Beobachtete Imports ausschließlich `ADVAPI32.dll`, `KERNEL32.dll`, `RPCRT4.dll`, +`msvcrt.dll`. `kernel32` wird vor `mincore` aufgelöst; dieser C-Trace benötigt +keine zusätzlichen präzisen Zeit-APIimporte der Rust-Readinesshülle. +Das sind Builddaten, noch kein nativer Loader-/RPCbeleg. + +Erhaltene frühere lokale Fälle werden nicht umgeschrieben: `58611089…` +scheiterte am Clang-Linkerpfad zu GCC-Runtimearchiven; `b900df4d…` wurde wegen +zusätzlicher aus `mincore` aufgelöster API-Set-Imports verweigert; der zunächst +fertig gebaute Pack `4d49b432…` scheiterte im nachfolgenden privaten +Manifestguard am Docker-root-eigenen Linkartefakt. Der neue Pack erhält nun +zusätzlich eine bytegleiche, vom Aufrufer besessene private Originalkopie. +Keine dieser Korrekturen verändert C/Auth/MIDL oder bestehende Produktdateien. + +Sechs manipulierte Berichtsfälle, nur numerische Ausgabe, historischer Bericht +nach gebundenem Cleanup und Readback ohne Upload/Start/Cleanup wurden lokal +mit ausdrücklich **simulierten** Transport-/Reportdaten geprüft. +`local-guards.json` beim aktuellen Manifest kennzeichnet `simulated_reports_only`, +`ssh_executed=false`, `native_executed=false`. Das ist keine simuliert als echt +ausgegebene SYSTEM-/RPC-/VM-Abnahme. Original131 und sämtliche neuen Inputs +wurden vor/nach dem Build unverändert gehasht. + +## Ursprünglich geplante Root-Ausführung + +Nur der Orchestrator benutzt den vorhandenen bestätigten Zugang zur festgelegten +Windows-Test-VM. Zugang bleibt in den privaten `credentials/` des Maincheckouts; +keine VM-Adresse oder Transportpräfixe in diesem Beleg. Der Notebook-Host +führt keinen Agenten und keinen Diagnosedienst aus. + +Zuerst `native.py prepare --manifest --access-root +--execute-native`: neuer privater Remote-Scratchfall und create-once Upload; +der Dienst startet dabei noch nicht. Anschließend `start` mit genau dieser +`--id` und `--execute-native`: eigener LocalSystem-Dienst wird einmal angelegt +und gestartet. Ein Create-once-Marker steht vor jeder möglichen Wirkung. + +`readback --id ` braucht **kein** `--execute-native` und +liest ausschließlich denselben Fall. Bei fehlendem/unklarem Ergebnis kein +neuer Start und kein erneuter Upload. Der tatsächliche numerische RPCcode +kann auch bei vollständig ausgeführter Diagnose ein Fehler sein; das ist +kein bestandener Status-/Clockbeleg. + +Erst danach gesondertes `cleanup --id --execute-native`. +Es verweigert fremde Binär-/Intent-/Servicekonfiguration, laufenden Dienst +oder wiederholte unklare Löschung. Bei Antwortverlust nur Readback. +Keine automatische Bereinigung im Leseweg, kein Stop fremder Dienste, +kein impliziter Reboot, kein Gatewechsel und kein RMM-Auftrag. + +## Tatsächlicher SYSTEM-Vergleich und getrennter Abschluss + +Root führte nach Source-/Manifest-/PowerShell-Parserprüfung den aktuellen +Pack8b5fc22c auf der Windows-Test-VM aus. Eigener Fall +`562ff9de-67ff-48a1-96f0-c2474b3b0777`: erst create-only Vorbereitung/Upload, +danach einmaliger eigener Dienststart. Das C-Programm bestätigte seinen +tatsächlichen SYSTEM-Token und führte genau einen Status-Traceaufruf aus. + +Tatsächliches Ergebnis: **RPC5, Stage90**, `rpc_exception=5`, kein normaler +nativer Return, kein Status. Der Dienst stoppte mit Exitcode0; dieser bestätigt +ausschließlich den abgeschlossenen Diagnosebericht, keinen erfolgreichen RPC. +Originalbericht danach im selben Fall separat rein lesend identisch bestätigt. +`diagnostic-result.json`-SHA256: +`5d8475f70a9cd6ef8713edb0264fa0d560499fa6abb6f5483e47b2332a4e6ca5`. + +Der Vergleich löst die Verweigerung durch den Callerwechsel nicht auf. Die +Erklärung allein durch LocalService ist damit nicht belegt. Ob SSPI, NPFS, +Serverautorisierung oder eine andere RPCschicht5 erzeugt, bleibt offen. Keine +beobachtete tatsächliche serverseitige Caller-/Service-SID und kein +Serveridentitäts- oder TrustedClock-Nachweis. + +Anschließend wurde ausschließlich der eigene exakt gebundene gestoppte Dienst +mit dem separaten Cleanupaufruf entfernt. Kein Stop eines bestehenden Diensts, +keine W32Time-ACL-/NTP-/Kontoänderung. Vorher/Nachher-RMM-/Serverabgleich +bestätigt dieselben PIDs/Prozessgeburten, Code-/Policydateien, PKI-/DB-/Lock- +Datei-IDs, Helperwitness und geschlossene Zähler/Flags. NachherbelegSHA256: +`65a9e98b6933a5c5f45acd8e6edcca837eaf28a7aeab0e8637ade8b09bf6c18c`. +Produktclock, Capabilities und Jobs bleiben gesperrt. Der nächste getrennte +Diagnosevorschlag erfasst ausschließlich begrenzte numerische RPC-EEInfo direkt +am Fehler; keine schwächere Authentisierung, Impersonation oder ACLänderung.