Repair only the missing stopped SYSTEM capture fixture on Windows
Rust development slice / linux (push) Failing after 6s

This commit is contained in:
2026-11-15 01:56:50 +01:00
parent 004aa142c1
commit c68bc0153e
4 changed files with 499 additions and 0 deletions
@@ -0,0 +1,105 @@
#!/usr/bin/env python3
"""One fixed original-case SYSTEM fixture repair; no RMM job or role start."""
import argparse
import json
from pathlib import Path
import subprocess
import uuid
import signed_clock_capture_acceptance as original
import signed_clock_capture_system_repair as repair
ROOT = Path(__file__).resolve().parents[2]
FOLDER = ROOT / 'devstate/windows-signed-clock-capture-system-repair/cff25311-d30b-495a-8b50-e0e28e2e5b48'
SCRIPT_SHA = 'ac3da3d86bd93497e8ecfe55369cb228ed0ce30c7f2301afb74463c789bb50ca'
GENERATOR_SHA = '9b44aa1491be2d154fb37fd0431370657f9623a2440649c29e910826beb44d2e'
NAME = 'SignedClockCaptureSystemRepair.ps1'
require, save, load = original.require, original.save, original.load
LAUNCH = r'''$ErrorActionPreference='Stop';$p=([Console]::In.ReadLine()|ConvertFrom-Json)
if((($p.PSObject.Properties.Name|Sort-Object)-join',')-cne'action,id,profile,script_sha256'-or$p.id-cne'efd17b43-7e04-49a7-9bd4-862d13365eec'-or$p.profile-cne'rmm.windows.raw-clock.original-system-create-repair.v1'-or$p.script_sha256-cne'ac3da3d86bd93497e8ecfe55369cb228ed0ce30c7f2301afb74463c789bb50ca'-or$p.action-notin@('repair','read')){throw 'Exact original fixture repair launch'}
$script='C:\ProgramData\RustDiscoveryBootstrap\ac3da3d86bd93497e8ecfe55369cb228ed0ce30c7f2301afb74463c789bb50ca\SignedClockCaptureSystemRepair.ps1'
$i=Get-Item -LiteralPath $script -Force;if($i.PSIsContainer-or($i.Attributes-band[IO.FileAttributes]::ReparsePoint)-or$i.Length-ne15551-or(Get-FileHash -LiteralPath $script -Algorithm SHA256).Hash.ToLowerInvariant()-cne$p.script_sha256){throw 'Exact original fixture repair bytes'}
$parent=$i.Directory;while($null-ne$parent){if($parent.Attributes-band[IO.FileAttributes]::ReparsePoint){throw 'No repair launch reparse ancestry'};$parent=$parent.Parent}
$a=Get-Acl -LiteralPath $script;if($a.GetOwner([Security.Principal.SecurityIdentifier]).Value-notin@('S-1-5-18','S-1-5-32-544')){throw 'Repair controller owner'};foreach($r in $a.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier])){if($r.AccessControlType-ne'Allow'-or$r.IdentityReference.Value-notin@('S-1-5-18','S-1-5-32-544')){throw 'Private repair controller DACL'}}
$global:RmmCaptureSystemRepairPayload=$p
& $script
'''
def verify():
require(original.sha(ROOT / 'deploy/windows/signed_clock_capture_acceptance.py') == repair.RUNNER_SHA,
'unchanged original capture operator')
require(original.sha(ROOT / 'deploy/windows/signed_clock_capture_system_repair.py') == GENERATOR_SHA,
'reviewed original-case repair generator')
original.private(FOLDER, True)
manifest = load(FOLDER / 'manifest.json')
require(manifest['original_case'] == repair.CASE and manifest['generator_sha256'] == GENERATOR_SHA
and manifest['repair_script_sha256'] == SCRIPT_SHA and manifest['repair_script_bytes'] == 15551,
'original fixed repair artifact')
script = FOLDER / NAME
original.private(script)
require(script.stat().st_size == 15551 and original.sha(script) == SCRIPT_SHA,
'reviewed fixed repair controller')
require(original.sha(repair.ORIGINAL / 'manifest.json') == repair.MANIFEST_SHA,
'original partial setup provenance')
def stage(access):
# Separate literal allowlist; the original capture transport is unchanged.
prepare = original.pipe.u.transport.PREPARE_SCRIPT.replace('TransportAcceptance.ps1', NAME)
observed = access.powershell(prepare, dict(sha256=SCRIPT_SHA))
if not observed['already_uploaded']:
credentials = original.pipe.cb.contract.protected_json(access.root / 'credentials/windows-dev-access.json')
prefix = credentials['ssh_prefix']
args = ['sftp'] + [part for part in prefix[1:-1] if part != '-T'] + ['-b', '-', prefix[-1]]
target = '/C:/ProgramData/RustDiscoveryBootstrap/' + SCRIPT_SHA + '/' + NAME
result = subprocess.run(args, input=('put ' + json.dumps(str(FOLDER / NAME)) + ' '
+ json.dumps(target) + '\n').encode(), capture_output=True, timeout=60)
require(result.returncode == 0, 'one exact repair transfer; lost reply read only')
observed = access.powershell(prepare, dict(sha256=SCRIPT_SHA))
require(observed['already_uploaded'] is True and observed['sha256'] == SCRIPT_SHA,
'immutable staged original-case repair')
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('action', choices=('stage', 'repair', 'read'))
args = parser.parse_args()
verify()
access = original.CaptureAccess(original.ACCESS_ROOT)
baseline = load(repair.ORIGINAL / 'baseline.json')
require(original.server_closed(access) == baseline['server'], 'original closed server counters and policy')
original.preserved(baseline['native'], original.native_witness(access))
action = args.action
if action != 'read':
save(FOLDER / (action + '-attempt.json'), dict(original_case=repair.CASE, once=True,
no_retry=True, script_sha256=SCRIPT_SHA, operator_sha256=original.sha(Path(__file__))))
if action == 'stage':
stage(access)
response = dict(staged=True, script_sha256=SCRIPT_SHA)
else:
if action == 'repair':
require((FOLDER / 'stage-reply.json').exists(), 'completed original stage; no restaging')
payload = dict(id=repair.CASE, profile=repair.PROFILE, action=action,
script_sha256=SCRIPT_SHA)
response = access.powershell(LAUNCH, payload, timeout=60)
identifier = str(uuid.uuid4()) if action == 'read' else action
save(FOLDER / (identifier + '-reply.json'), response)
after_server, after_native = original.server_closed(access), original.native_witness(access)
require(after_server == baseline['server'], 'closed server policy and counters unchanged')
original.preserved(baseline['native'], after_native)
save(FOLDER / (identifier + '-preservation.json'), dict(server=after_server, native=after_native,
original_case=repair.CASE, response_sha256=original.sha(FOLDER / (identifier + '-reply.json')),
no_rmm_jobs=True, no_role_start=True, setup_completed=False))
if action == 'repair':
require(response.get('system_created_stopped') is True and response.get('setup_completed') is False
and response.get('service_started') is False, 'only own SYSTEM fixture created stopped')
print(json.dumps(dict(action=action, original_case=repair.CASE, read_only=action == 'read',
preservation_sha256=original.sha(FOLDER / (identifier + '-preservation.json')),
response_sha256=original.sha(FOLDER / (identifier + '-reply.json')), preserved=True,
system_created_stopped=response.get('system_created_stopped'), setup_completed=False)))
if __name__ == '__main__':
main()
@@ -0,0 +1,216 @@
#!/usr/bin/env python3
"""Prepare one original-case-bound SYSTEM creation repair; no transport or execution.
Never replay the original setup. The generated controller can create only the
missing fixed SYSTEM fixture, or read its original repair records. It does not
finish setup, copy an executable, start/stop a service or remove anything.
"""
import argparse
import hashlib
import json
import os
from pathlib import Path
import stat
import uuid
ROOT = Path(__file__).resolve().parents[2]
CASE = 'efd17b43-7e04-49a7-9bd4-862d13365eec'
ORIGINAL = ROOT / 'devstate/windows-signed-clock-capture-native' / CASE
RUNNER_SHA = 'dd6c575a119751429448e40e6f306cf79efa3a86c49bf2cd32a7783937177770'
MANIFEST_SHA = '806c062bdd458627cf44ff1ef3f27738e1ebf2f407a96f772223efef267db0b1'
CONTROLLER_SHA = '89c19138e2804f263f1875c7697a7d53f54f40722101677b4d29538c917196f4'
EXE_SHA = '601c27a43fb67c662f926f9dc289a23a5c31c7e27f62901a77fc9ceaafaea7fb'
EXE_BYTES = 8566784
MARKERS_SHA = 'ff8e2eef73139c8350aa0f86c6fed5125fce95f79d535f25224829ce4fa9c565'
PROFILE = 'rmm.windows.raw-clock.original-system-create-repair.v1'
def require(value, message):
if not value:
raise RuntimeError(message)
def sha(raw):
return hashlib.sha256(raw).hexdigest()
def private_read(path, limit=2 * 1024 * 1024):
fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW)
with os.fdopen(fd, 'rb') as stream:
meta = os.fstat(stream.fileno())
require(stat.S_ISREG(meta.st_mode) and meta.st_nlink == 1 and meta.st_uid == os.getuid()
and stat.S_IMODE(meta.st_mode) == 0o600 and meta.st_size <= limit, 'private bounded original evidence')
raw = stream.read(limit + 1)
after = os.fstat(stream.fileno())
require(len(raw) <= limit and (meta.st_ino, meta.st_size, meta.st_mtime_ns, meta.st_ctime_ns)
== (after.st_ino, after.st_size, after.st_mtime_ns, after.st_ctime_ns), 'unchanged original evidence')
return raw
def write(path, raw):
fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, 0o600)
with os.fdopen(fd, 'wb') as stream:
stream.write(raw)
stream.flush()
os.fsync(stream.fileno())
fd = os.open(path.parent, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW)
try:
os.fsync(fd)
finally:
os.close(fd)
def canonical(value):
return (json.dumps(value, sort_keys=True, separators=(',', ':')) + '\n').encode()
NATIVE = r'''
Add-Type -TypeDefinition @'
using System;
using System.ComponentModel;
using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;
public static class RmmCaptureSystemRepair {
const string LocalName="RmmSignedClockCaptureLocalService";
const string SystemName="RmmSignedClockCaptureSystem";
const string SystemCommand="\"C:\\ProgramData\\RustDiscoverySignedClockCapture\\efd17b43-7e04-49a7-9bd4-862d13365eec\\SignedClockCapture.exe\" --service efd17b43-7e04-49a7-9bd4-862d13365eec system";
[DllImport("advapi32.dll",EntryPoint="OpenSCManagerW",ExactSpelling=true,CharSet=CharSet.Unicode,SetLastError=true)] static extern IntPtr OpenManager(string machine,string database,uint access);
[DllImport("advapi32.dll",EntryPoint="CreateServiceW",ExactSpelling=true,CharSet=CharSet.Unicode,SetLastError=true)] static extern IntPtr CreateService(IntPtr manager,string name,string display,uint access,uint type,uint start,uint error,string command,string group,IntPtr tag,string dependencies,string account,string password);
[DllImport("advapi32.dll",EntryPoint="OpenServiceW",ExactSpelling=true,CharSet=CharSet.Unicode,SetLastError=true)] static extern IntPtr OpenService(IntPtr manager,string name,uint access);
[DllImport("advapi32.dll",SetLastError=true)] [return:MarshalAs(UnmanagedType.Bool)] static extern bool CloseServiceHandle(IntPtr handle);
[DllImport("advapi32.dll",EntryPoint="ChangeServiceConfig2W",ExactSpelling=true,SetLastError=true)] [return:MarshalAs(UnmanagedType.Bool)] static extern bool ChangeServiceConfig2(Service handle,uint level,ref uint value);
[DllImport("advapi32.dll",SetLastError=true)] [return:MarshalAs(UnmanagedType.Bool)] static extern bool QueryServiceStatusEx(Service handle,int level,out Status value,int size,out int needed);
[DllImport("advapi32.dll",SetLastError=true)] [return:MarshalAs(UnmanagedType.Bool)] static extern bool SetServiceObjectSecurity(Service handle,uint info,IntPtr descriptor);
[DllImport("advapi32.dll",EntryPoint="ConvertStringSecurityDescriptorToSecurityDescriptorW",ExactSpelling=true,CharSet=CharSet.Unicode,SetLastError=true)] [return:MarshalAs(UnmanagedType.Bool)] static extern bool ConvertSecurity(string text,uint revision,out IntPtr descriptor,out uint size);
[DllImport("kernel32.dll")] static extern IntPtr LocalFree(IntPtr value);
[StructLayout(LayoutKind.Sequential)] public struct Status {public uint Type,State,Controls,Win32Exit,SpecificExit,Checkpoint,WaitHint,Pid,Flags;}
static Exception Failed(string step){int code=Marshal.GetLastWin32Error();return new Win32Exception(code,"CAPTURE_SYSTEM_REPAIR_"+step);}
public sealed class Service:SafeHandleZeroOrMinusOneIsInvalid {
internal Service(IntPtr value):base(true){SetHandle(value);}
protected override bool ReleaseHandle(){return CloseServiceHandle(handle);}
public Status Read(){Status value;int needed;if(!QueryServiceStatusEx(this,0,out value,Marshal.SizeOf(typeof(Status)),out needed))throw Failed("QueryServiceStatusEx");return value;}
}
static IntPtr Manager(uint access){IntPtr value=OpenManager(null,null,access);if(value==IntPtr.Zero)throw Failed("OpenSCManagerW");return value;}
static Service OpenFixed(string name){IntPtr manager=Manager(1);try{IntPtr value=OpenService(manager,name,4);if(value==IntPtr.Zero)throw Failed("OpenServiceW");return new Service(value);}finally{CloseServiceHandle(manager);}}
public static Service OpenLocal(){return OpenFixed(LocalName);}
public static Service OpenSystem(){return OpenFixed(SystemName);}
public static Service CreateSystemOnce(){
IntPtr manager=Manager(3);try{
// Literal managed null is passed to the P/Invoke here. No PowerShell string
// binding or caller-selected service/account/path reaches CreateServiceW.
IntPtr value=CreateService(manager,SystemName,SystemName,0xf01ff,16,3,1,SystemCommand,null,IntPtr.Zero,null,null,null);
if(value==IntPtr.Zero)throw Failed("CreateServiceW");
Service service=new Service(value);try{
uint sid=1;if(!ChangeServiceConfig2(service,5,ref sid))throw Failed("ChangeServiceConfig2W");
IntPtr descriptor;uint bytes;if(!ConvertSecurity("D:P(A;;GA;;;SY)(A;;GA;;;BA)",1,out descriptor,out bytes))throw Failed("ConvertSecurityW");
try{if(!SetServiceObjectSecurity(service,4,descriptor))throw Failed("SetServiceObjectSecurity");}finally{LocalFree(descriptor);}
return service;
}catch{service.Dispose();throw;}
}finally{CloseServiceHandle(manager);}
}
}
'@
'''
HEADER = r'''
$ErrorActionPreference='Stop';$request=$global:RmmCaptureSystemRepairPayload
if(!$request-or(($request.PSObject.Properties.Name|Sort-Object)-join',')-cne'action,id,profile,script_sha256'-or$request.id-cne'efd17b43-7e04-49a7-9bd4-862d13365eec'-or$request.profile-cne'rmm.windows.raw-clock.original-system-create-repair.v1'-or$request.action-notin@('repair','read')-or$request.script_sha256-notmatch'^[a-f0-9]{64}$'){throw 'Fixed original system repair request'}
$p=@{id='efd17b43-7e04-49a7-9bd4-862d13365eec'};$base='C:\ProgramData\RustDiscoverySignedClockCapture';$case=Join-Path $base $p.id;$control=Join-Path $case 'control';$exe=Join-Path $case 'SignedClockCapture.exe';$boot='C:\ProgramData\RustDiscoveryBootstrap'
$names=@('RmmSignedClockCaptureLocalService','RmmSignedClockCaptureSystem');$tags=@('local-service','system');$accounts=@('NT AUTHORITY\LocalService','LocalSystem');$sys='S-1-5-18';$admin='S-1-5-32-544'
'''
BODY = r'''
if($PSCommandPath-cne(Join-Path (Join-Path $boot $request.script_sha256) 'SignedClockCaptureSystemRepair.ps1')-or(HashFile $PSCommandPath)-cne$request.script_sha256){throw 'Actual exact repair controller'}
Check $PSCommandPath $false;foreach($dir in @($base,$case,$control)){Check $dir $true}
$oldController=Join-Path (Join-Path $boot '89c19138e2804f263f1875c7697a7d53f54f40722101677b4d29538c917196f4') 'SignedClockCaptureAcceptance.ps1';Check $oldController $false;if((HashFile $oldController)-cne'89c19138e2804f263f1875c7697a7d53f54f40722101677b4d29538c917196f4'){throw 'Original controller hash'}
$staged=Join-Path (Join-Path $boot '601c27a43fb67c662f926f9dc289a23a5c31c7e27f62901a77fc9ceaafaea7fb') 'SignedClockCapture.exe';Check $staged $false;if((Get-Item -LiteralPath $staged).Length-ne8566784-or(HashFile $staged)-cne'601c27a43fb67c662f926f9dc289a23a5c31c7e27f62901a77fc9ceaafaea7fb'){throw 'Original staged executable'}
$intent=ReadJson (Join-Path $control 'intent.json');if((($intent.PSObject.Properties.Name|Sort-Object)-join',')-cne'action,exe_bytes,exe_sha256,id,manifest_sha256,profile,script_sha256'-or$intent.action-cne'setup'-or$intent.id-cne$p.id-or$intent.profile-cne'rmm.windows.raw-clock.two-role-bootstrap.v1'-or$intent.exe_bytes-ne8566784-or$intent.exe_sha256-cne'601c27a43fb67c662f926f9dc289a23a5c31c7e27f62901a77fc9ceaafaea7fb'-or$intent.script_sha256-cne'89c19138e2804f263f1875c7697a7d53f54f40722101677b4d29538c917196f4'-or$intent.manifest_sha256-cne'806c062bdd458627cf44ff1ef3f27738e1ebf2f407a96f772223efef267db0b1'){throw 'Exact original setup intent'}
$active=ReadJson (Join-Path $base 'active.json');if((($active.PSObject.Properties.Name|Sort-Object)-join',')-cne'id,manifest_sha256,no_retry,script_sha256'-or$active.id-cne$p.id-or$active.manifest_sha256-cne$intent.manifest_sha256-or$active.script_sha256-cne$intent.script_sha256-or$active.no_retry-ne$true){throw 'Same original active campaign'}
$allowed=@('intent.json','local-service-create-attempt.json','local-service-created.json','system-create-attempt.json','system-create-repair-attempt.json','system-create-repair-created.json','system-create-repair-failure.json');foreach($item in @(Get-ChildItem -LiteralPath $control -Force)){if($item.PSIsContainer-or$item.Name-notin$allowed){throw 'Unexpected campaign progress: no repair'}}
foreach($n in @(0,1)){$attempt=ReadJson (Join-Path $control ($tags[$n]+'-create-attempt.json'));if((($attempt.PSObject.Properties.Name|Sort-Object)-join',')-cne'command,create_once'-or$attempt.create_once-ne$true-or$attempt.command-cne(Command $n)){throw 'Original exact service attempt'}}
$made=ReadJson (Join-Path $control 'local-service-created.json');$local=Service 0;if((($made.PSObject.Properties.Name|Sort-Object)-join',')-cne'create_once,service'-or$made.create_once-ne$true-or!$local-or!(Equal $local $made.service)){throw 'Same original LocalService definition'}
$localHandle=[RmmCaptureSystemRepair]::OpenLocal();try{$localStatus=$localHandle.Read();if($localStatus.State-ne1){throw 'Original LocalService must remain stopped'}}finally{$localHandle.Dispose()}
foreach($path in @($exe,(Join-Path $case 'local-service'),(Join-Path $case 'system'))){if(Test-Path -LiteralPath $path){throw 'Unexpected setup completion or prior role entry'}}
$repairAttempt=Join-Path $control 'system-create-repair-attempt.json';$repairCreated=Join-Path $control 'system-create-repair-created.json';$repairFailure=Join-Path $control 'system-create-repair-failure.json'
$system=Get-CimInstance Win32_Service -Filter "Name='RmmSignedClockCaptureSystem'" -OperationTimeoutSec 5
if($request.action-ceq'read'){
$records=[ordered]@{};foreach($leaf in @('system-create-repair-attempt.json','system-create-repair-created.json','system-create-repair-failure.json')){$path=Join-Path $control $leaf;$records[$leaf]=$null;if(Test-Path -LiteralPath $path){$records[$leaf]=ReadJson $path}}
$systemMetadata=$null;if($system){$systemMetadata=@{command=$system.PathName;account=$system.StartName;start=$system.StartMode;type=$system.ServiceType;state=$system.State;definition_unverified=$true}}
@{id=$p.id;read_only=$true;local_service_verified_stopped=$true;system_present=[bool]$system;system=$systemMetadata;records=$records;setup_completed=$false;service_started=$false;calibrated=$false;clock_authority=$false}|ConvertTo-Json -Depth 24 -Compress;exit 0
}
if($system-or(Test-Path -LiteralPath $repairAttempt)-or(Test-Path -LiteralPath $repairCreated)-or(Test-Path -LiteralPath $repairFailure)){throw 'Existing system or repair attempt: original read only'}
WriteNew $repairAttempt @{id=$p.id;profile=$request.profile;script_sha256=$request.script_sha256;original_manifest_sha256=$intent.manifest_sha256;original_controller_sha256=$intent.script_sha256;create_once=$true;system_account_null_inside_csharp=$true;command=(Command 1);no_retry=$true}
$handle=$null
try{
$handle=[RmmCaptureSystemRepair]::CreateSystemOnce();$status=$handle.Read();if($status.State-ne1){throw 'New SYSTEM fixture must remain stopped'}
$created=Service 1;if(!$created){throw 'New fixed SYSTEM definition absent'}
$still=Service 0;if(!(Equal $still $made.service)){throw 'Original LocalService definition changed'}
WriteNew $repairCreated @{id=$p.id;profile=$request.profile;script_sha256=$request.script_sha256;service=$created;stopped=$true;create_once=$true;setup_completed=$false;service_started=$false;calibrated=$false;clock_authority=$false}
@{id=$p.id;system_created_stopped=$true;setup_completed=$false;service_started=$false;calibrated=$false;clock_authority=$false}|ConvertTo-Json -Compress
}catch{
$inner=$_.Exception;while($null-ne$inner.InnerException){$inner=$inner.InnerException};$native=$null;$step='managed_postcondition';if($inner-is[ComponentModel.Win32Exception]){$native=$inner.NativeErrorCode;if($inner.Message-match'^CAPTURE_SYSTEM_REPAIR_[A-Za-z0-9]+$'){$step=$inner.Message}}
if(!(Test-Path -LiteralPath $repairFailure)){WriteNew $repairFailure @{id=$p.id;profile=$request.profile;script_sha256=$request.script_sha256;failed=$true;step=$step;native_error_code=$native;read_original_case_only=$true}}
throw 'SYSTEM repair failed; read the original case only; do not retry'
}finally{if($null-ne$handle){$handle.Dispose()}}
'''
def helpers(original):
# Reuse only the exact original pure ACL/metadata/record helpers. Never
# import/dot-source/execute the original controller or its setup branch.
def section(start, end):
require(original.count(start) == 1 and original.count(end) == 1, 'unique original helper boundaries')
return original[original.index(start):original.index(end)]
output = section('function HashBytes', 'function NewDir')
output += section('function WriteNew', 'function Original')
require('function NewDir' not in output and 'CreateOnce' not in output and 'function ReadAll' not in output,
'only bounded original helper subset')
return output
def prepare():
require(sha((ROOT / 'deploy/windows/signed_clock_capture_acceptance.py').read_bytes()) == RUNNER_SHA,
'original runner unchanged')
original_manifest = private_read(ORIGINAL / 'manifest.json')
original_script = private_read(ORIGINAL / 'SignedClockCaptureAcceptance.ps1')
markers = private_read(ORIGINAL / 'marker-query-result-5c07d236-a249-450e-83f8-e5c22c49bae3.json')
require(sha(original_manifest) == MANIFEST_SHA and sha(original_script) == CONTROLLER_SHA
and sha(markers) == MARKERS_SHA, 'exact original partial-case provenance')
marker_value = json.loads(markers)
require(marker_value == {'names': ['intent.json', 'local-service-create-attempt.json',
'local-service-created.json', 'system-create-attempt.json'], 'read_only': True},
'actual original four-marker partial state')
# Read the already-qualified public executable only; never credentials/pins/keys.
executable = private_read(ORIGINAL / 'SignedClockCapture.exe', EXE_BYTES)
require(len(executable) == EXE_BYTES and sha(executable) == EXE_SHA, 'original qualified executable unchanged')
script = (HEADER + helpers(original_script.decode()) + NATIVE + BODY).encode('ascii')
require(len(script) <= 32768, 'bounded single-purpose repair controller')
state = ROOT / 'devstate/windows-signed-clock-capture-system-repair'
state.mkdir(mode=0o700, parents=True, exist_ok=True)
require(state.stat().st_uid == os.getuid() and stat.S_IMODE(state.stat().st_mode) == 0o700,
'private local repair artifact root')
folder = state / str(uuid.uuid4())
folder.mkdir(mode=0o700)
write(folder / 'SignedClockCaptureSystemRepair.ps1', script)
for action in ('repair', 'read'):
write(folder / ('payload-' + action + '.json'), canonical(dict(id=CASE, profile=PROFILE,
action=action, script_sha256=sha(script))))
manifest = {'profile': PROFILE, 'original_case': CASE, 'original_manifest_sha256': MANIFEST_SHA,
'original_controller_sha256': CONTROLLER_SHA, 'original_runner_sha256': RUNNER_SHA,
'original_marker_receipt_sha256': MARKERS_SHA, 'exe_sha256': EXE_SHA,
'repair_script_sha256': sha(script), 'repair_script_bytes': len(script),
'generator_sha256': sha(Path(__file__).read_bytes()), 'target_executed': False,
'no_original_controller_replay': True, 'no_start_stop_delete_or_setup_completion': True}
write(folder / 'manifest.json', canonical(manifest))
print(json.dumps({'path': str(folder), **manifest}, sort_keys=True))
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('command', choices=['prepare'])
parser.parse_args()
prepare()
if __name__ == '__main__':
main()
+7
View File
@@ -1,5 +1,12 @@
# Übergabe — Linux-MVP abgeschlossen, Windows wird fortgesetzt
**Windows-Messfixture eng repariert:** Originalfallefd17b43, separate
SYSTEM-Erstellung mit C#-internem NULL erfolgreich, beide eigenen Messdienste
verifiziert gestoppt; separater Readback und sämtliche RMM-/Serverzeugen erhalten.
Originalsetup bleibt fehlgeschlagen, keine Rollenstarts/Calibration/Clockfreigabe.
[Reparatur und Grenzen](windows-raw-capture-system-repair.md).
**Finaler Windows-Kontextfence Linux-first bestanden:** Originalfall1e179c84,
volle15er-Liste, nur geänderten Fencetest1PASS/14filtered ausgeführt; separater
Readback vollständig, bekannte Runtimezeugen erhalten. Recheck und erkannter
+171
View File
@@ -0,0 +1,171 @@
# Eigener SYSTEM-Reparaturschritt des bestehenden Rohcapturefalls
Der einzige Zielfall bleibt `efd17b43-7e04-49a7-9bd4-862d13365eec`.
`deploy/windows/signed_clock_capture_system_repair.py prepare` erzeugt nur lokal
einen gesonderten festen Controller. Er enthält keine SSH-/Übertragungs- oder
Ausführungsfunktion. Originalrunner, Originalcontroller, Manifest und sämtliche
alten Marker werden weder verändert noch erneut ausgeführt.
## Tatsächlicher Befund
Das ursprüngliche Setup scheiterte auf der zusammengefassten PS-Zeile138.
Der lesende Markerbeleg
`ff8e2eef73139c8350aa0f86c6fed5125fce95f79d535f25224829ce4fa9c565`
enthält `intent.json`, `local-service-create-attempt.json`,
`local-service-created.json` und `system-create-attempt.json`. Der ebenfalls
lesende Servicebeleg findet den exakten LocalService gestoppt/Manual mit
UNRESTRICTED-SID und der eingerichteten Admin-/SYSTEM-DACL; SYSTEM fehlt.
Damit kam der erste `CreateOnce` vollständig zurück und der Fehler liegt sehr
nahe an der zweiten Dienstanlage. Der ursprüngliche NativeErrorCode wurde
nicht gesichert; beispielsweise1057 wird deshalb **nicht** als Messwert behauptet.
Der konkrete Quellfehlerkandidat ist die Übergabe von PS-`$null` an den
C#-Stringparameter `account`. Für einen echten .NET-null-String sieht PowerShell
den Typ [NullString](https://learn.microsoft.com/en-us/dotnet/api/system.management.automation.language.nullstring)
vor, auch in5.1. [CreateServiceW](https://learn.microsoft.com/en-us/windows/win32/api/winsvc/nf-winsvc-createservicew)
dokumentiert NULL als LocalSystem-Default; ein leerer Accountstring ist kein
dokumentierter Ersatz. Der Restzustand passt zu diesem Binderfehler, beweist
die verlorene ursprüngliche Nativefehlernummer jedoch nicht.
Die ursprünglichen SafeHandle-/Disposepfade schließen Handles, löschen aber
keinen Dienst; ihr `ReleaseHandle` gibt nur ein Boolean zurück. Eine solche
Schließung erklärt hier nicht den expliziten `Win32Exception`-Pfad. Separat
wurde eine tatsächliche falsche Erfolgsprüfung gefunden: `Service.Read` verlangt
`pcbBytesNeeded==sizeof(Status)` auch nach erfolgreichem
[QueryServiceStatusEx](https://learn.microsoft.com/en-us/windows/win32/api/winsvc/nf-winsvc-queryservicestatusex).
Dieser Ausgabewert ist für den Fall `ERROR_INSUFFICIENT_BUFFER` beschrieben;
die Größe darf kein zusätzlicher Erfolgsindikator sein. Die Reparaturklasse
prüft daher nur den tatsächlichen BOOL-Erfolg und sichert einen Fehler sofort.
Der unveränderte Rohcaptureprozess verwendet Token, Service-SID-Lookup und
gehaltene Dateien. Er ruft nicht `PeerProof::for_service`/`OpenServiceW` auf.
Ein zusätzlicher LocalService-SCM-ACE ist für diesen konkreten Rohcapturepfad
deshalb nicht erforderlich; die gegenwärtige Dienst-DACL wird nicht erweitert.
Spätere installierte Adapterpfade sind gesondert zu beurteilen.
## Implementierter, noch nicht am Ziel ausgeführter Reparaturumfang
Lokaler Paketfall
`devstate/windows-signed-clock-capture-system-repair/cff25311-d30b-495a-8b50-e0e28e2e5b48`:
Controller15551Bytes, SHA256
`ac3da3d86bd93497e8ecfe55369cb228ed0ce30c7f2301afb74463c789bb50ca`.
Generator-SHA256
`9b44aa1491be2d154fb37fd0431370657f9623a2440649c29e910826beb44d2e`.
Die lokalen Manifest-/Payloaddateien nennen weiterhin ausschließlich den
ursprünglichen Zielfall. Eine neue lokale Artefakt-ID ist kein neuer Zielversuch.
Vor der einzigen neuen SystemCreate-Operation prüft der Controller:
- Eigenen tatsächlich ausgeführten Hashpfad sowie Originalcontroller89c19138…,
Originalmanifest806c062b… über den ursprünglichen Setupintent/active-Bezug
und die unveränderte gestagte EXE601c27a4… mit8566784Bytes.
- Geschützte Originalverzeichnisse und exakt erlaubten Markerfortschritt,
beide ursprünglichen Createattempts samt fester CLI und den bereits erzeugten
LocalService anhand seines originalen Createdbelegs, der Service-SIDart,
ACLhash, Startart, Konto, Typ und Abhängigkeiten. Ein gehaltener SCM-Queryhandle
muss ihn als gestoppt melden.
- Noch fehlenden SYSTEM-Dienst und fehlende Repairattempt-/Created-/Failuremarker.
Noch keine Rollenverzeichnisse, installierte Case-EXE oder weitere Start-/
Setupmarker. Fremde oder weiter fortgeschrittene Zustände verweigern.
Er schreibt dann ausschließlich einen neuen create-only
`system-create-repair-attempt.json`, legt SYSTEM genau einmal an, setzt SIDart1
und dieselbe enge Dienst-DACL und prüft den weiterhin gestoppten Zustand.
Name und CLI sind feste C#-Konstanten; **NULL entsteht innerhalb C#**, kein
Accountstring kommt aus PowerShell oder Payload. Nativeaufrufe erhalten feste
Schrittnamen und sofort gesicherte NativeErrorCodes. SafeHandleparameter
halten den SCM-Handle während des nativen Reads gültig. Erfolg und Fehler
erhalten eigene neue Marker, die alten Systemattempts bleiben unangetastet.
Es gibt nur `repair` und `read`. Nach fehlender Antwort/Fehler ausschließlich
`read` des Originalfalls, niemals erneut `repair` oder Original-`setup`.
Ein nach CreateService fehlgeschlagener SID-/ACLschritt bleibt offen sichtbar;
kein automatisches Delete oder vermeintlicher Erfolg. `read` zeigt die feste
SYSTEM-Definition in einem solchen Restzustand ausdrücklich als unverifiziert.
Keine Starts/Stops/Deletes, Zeitsetter, W32Time-/RMM-Änderung, EXE-Kopie oder
Setupcompletion. Ein erfolgreicher SystemCreate allein bedeutet **keine
Capturebereitschaft**.
Tatsächlich lokal: Python-AST, Pakethashes, ursprüngliche Fallbindung und
begrenzter Mutationsumfang geprüft. Kein PowerShell-/C#-Compiler ist hier
verfügbar; native Parser-/Add-Type-Prüfung und sämtliche Zielaktionen wurden
durch diesen Worker nicht ausgeführt. Diese Grenzen stehen im lokalen Beleg.
## Getrennte nächste Finalisierung und Controllerkorrektur: Vorschlag
Der Originalsetupfehler lag vor Service-SID-Auflösung, Reader-ACLs, beiden
Rollenverzeichnissen, EXE-Kopie und Setupcompletion. Ein weiterer eigener
Originalfallcontroller muss diesen fehlenden Rest explizit abschließen:
1. Neue create-only Finalisierungsabsicht nach ursprünglicher Fall-/Hashbindung,
originalem LS-Createdbeleg und erfolgreichem neuen SYSTEM-Repaircreatedbeleg.
Beide festen Dienste müssen exakt passende, weiterhin gestoppte Definitionen
haben; beide tatsächlichen `NT SERVICE`-SIDs unabhängig auflösen und prüfen.
Keine Rawrollen-Startattempts/-Intents/-Ergebnisse zulassen.
2. Die bisher rootgeschützten Base-/Case-ACLs auf genau die zwei eigenen
Reader-SIDs ergänzen. Ausschließlich die zwei noch fehlenden eigenen
Rollenverzeichnisse create-only mit dem jeweils eigenen Writer-SID anlegen;
die unveränderte EXE ausschließlich create-only aus dem gesicherten Staging
übernehmen, Hash/Größe und finales ACLprofil erneut prüfen. Kein breites
ACL-Repair, fremdes Objekt oder Überschreiben.
3. Einen **neuen** `setup-repair-complete.json` schreiben. Originales Setup und
dessen fehlender `setup-complete.json` werden nicht rückwirkend erfolgreich
erklärt. Eine partielle neue Finalisierung bleibt als eigener Intent ohne
Erfolg; keine automatische Wiederholung/Resume-Engine.
4. Einen weiteren getrennt gehashten Controller aus den Originalbytes erzeugen:
Original-`setup` dauerhaft verweigern; für nachfolgende Start-/Read-/Cleanup-
Aktionen den neuen Completionbeleg sowie originalen LS- und reparierten
SYSTEM-Createdbezug verlangen. Originalcontroller/Manifesthash zusätzlich
prüfen, eigene Scriptpfad-/Hashprüfung auf den neuen Controller binden.
Die einzige Änderung am nativen Statusread ist das Entfernen der falschen
`pcbBytesNeeded`-Erfolgsgleichheit. Kein Clock-/Capturealgorithmuswechsel.
Erst ein eindeutiger eigener Rollenstartintent erlaubt anschließend eine einzige
Rohcaptureausführung. LS zuerst, SYSTEM erst nach eindeutig erfolgreichem LS-
Originalergebnis; Prozessgeneration-/Watchdog- und Ausgabebelege bleiben wie im
Originalprofil erforderlich. Cleanup ist separat: nur verifizierte eigene
gestoppte Dienste über gehaltene SCM-Handles und passende originale/reparierte
Createdbelege löschen, niemals ein freier Name, unbekannter Prozess oder blindes
Stoppen. Bei unklarem Start-/Exit-/Deletezustand ausschließlich Originalfall
lesen. Die hier gelieferte SystemCreate-Reparatur implementiert diese spätere
Finalisierung und Cleanupkorrektur noch nicht.
## Tatsächliche native Reparatur, 2026-11-15
Root führte nach unabhängigem Review den unveränderten Reparaturcontroller
`ac3da3d86bd93497e8ecfe55369cb228ed0ce30c7f2301afb74463c789bb50ca`
im Originalfall efd17b43 aus. Zuvor bestätigte die Windows-VM
PowerShell5.1.26100.9818:0 ASTfehler, isolierte C#-Kompilierung bestanden,
Controller dabei nicht ausgeführt. Syntaxreceipt
`f0586ef81853cc942b8043088b9c46336808c41cb89aa6d1afaff0e0b1483b30`.
Der dünne native Operator `signed_clock_capture_repair_acceptance.py`
(SHA256 `85fa12492c303beec4539fe38fc3fa81455594a4a62722aa8950b1497f4016f8`)
verwendet ausschließlich den bestehenden gepinnten Transport und seinen einen
festen zusätzlichen Stagenamen. Ein unabhängiger Review fand vor Ausführung
die fehlende Bindung lokaler Nutzlastdateien an die ausgewählte CLI-Aktion;
diese wurde durch vollständig im Code festgelegte Nutzlasten behoben. Ein
`read` kann deshalb keine `repair`-Nutzlast aus einer Datei übernehmen.
Staging erfolgreich, anschließend genau ein Reparaturaufruf erfolgreich:
SYSTEM-Messdienst neu angelegt und tatsächlich gestoppt, LocalService weiterhin
verifiziert gestoppt. `setup_completed=false`, `service_started=false`.
Repairreply-SHA256
`b87746dc066fc255d2cbf1871698811203d38410e27c8d6d51d2d38ea7752c96`,
zugehöriger Erhaltungsbeleg
`a1bb8a42e22f2d0263dc381bd675134effe6555867b57b7f4fae28eb6f319ad6`.
Die sechs vollständigen nativen RMM-Witnessfelder einschließlich Helpermetadata
und stabiler Journalidentität sowie aktuelle Serverpolicy/Zähler sind vorher
und nachher unverändert. Linux31/31/27/0, Windows0/0/0/0; kein RMM-Job.
Das ursprüngliche Setup bleibt fehlgeschlagen. Seine Bytes und Marker bleiben
erhalten; ein `setup-complete` oder Rohmessbericht wurde nicht nachträglich
erfunden. Es gab weder Rollenstart noch Clockpin-/RMM-Konfigurationsänderung,
Kalibrierung, W32Time-Anweisung oder Jobfreigabe. Die noch fehlende endgültige
Messfixtureeinrichtung und anschließenden beiden Rollenprüfungen bleiben offen.
Separater tatsächlicher Original-Readback bestanden: Antwort-SHA256
`fad16846247eb6d84f352802aeb0dbc368f32cbee1512ca4c4d63b22aedb62b8`,
Erhaltungsreceipt
`336b4ff6cbf718658dd3c459ac716bbaee2e2e82c60bac79ac6a9631ce3e66e7`.
Er liest die ursprünglichen neuen Reparaturmarker, startet und repariert nichts.