From c68bc0153e342b6516d78469e0483d7677ae6e92 Mon Sep 17 00:00:00 2001 From: Kevin Janssen Date: Sun, 15 Nov 2026 01:56:50 +0100 Subject: [PATCH 1/2] Repair only the missing stopped SYSTEM capture fixture on Windows --- .../signed_clock_capture_repair_acceptance.py | 105 +++++++++ .../signed_clock_capture_system_repair.py | 216 ++++++++++++++++++ docs/handover.md | 7 + docs/windows-raw-capture-system-repair.md | 171 ++++++++++++++ 4 files changed, 499 insertions(+) create mode 100644 deploy/windows/signed_clock_capture_repair_acceptance.py create mode 100644 deploy/windows/signed_clock_capture_system_repair.py create mode 100644 docs/windows-raw-capture-system-repair.md diff --git a/deploy/windows/signed_clock_capture_repair_acceptance.py b/deploy/windows/signed_clock_capture_repair_acceptance.py new file mode 100644 index 0000000..083f550 --- /dev/null +++ b/deploy/windows/signed_clock_capture_repair_acceptance.py @@ -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() diff --git a/deploy/windows/signed_clock_capture_system_repair.py b/deploy/windows/signed_clock_capture_system_repair.py new file mode 100644 index 0000000..66b12af --- /dev/null +++ b/deploy/windows/signed_clock_capture_system_repair.py @@ -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() diff --git a/docs/handover.md b/docs/handover.md index 89ae86a..26fa487 100644 --- a/docs/handover.md +++ b/docs/handover.md @@ -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 diff --git a/docs/windows-raw-capture-system-repair.md b/docs/windows-raw-capture-system-repair.md new file mode 100644 index 0000000..a8d2fc9 --- /dev/null +++ b/docs/windows-raw-capture-system-repair.md @@ -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. From 2c0f07046efa08132f6ed584b4e686f5f88d46fd Mon Sep 17 00:00:00 2001 From: Kevin Janssen Date: Sun, 15 Nov 2026 01:57:21 +0100 Subject: [PATCH 2/2] Qualify protected Chrony socket permissions on cloud Linux --- crates/time-source-linux/src/native.rs | 36 +- deploy/server_time_source_bootstrap.py | 2 +- deploy/time_source_socket_linux_acceptance.py | 309 ++++++++++++++++++ docs/handover.md | 7 + docs/server-time-source-bootstrap.md | 17 +- docs/server-time-source.md | 43 ++- 6 files changed, 404 insertions(+), 10 deletions(-) create mode 100644 deploy/time_source_socket_linux_acceptance.py diff --git a/crates/time-source-linux/src/native.rs b/crates/time-source-linux/src/native.rs index 21f23d8..68f29ec 100644 --- a/crates/time-source-linux/src/native.rs +++ b/crates/time-source-linux/src/native.rs @@ -675,6 +675,17 @@ impl Drop for Client { } } +// Linux pathname DGRAM send requires socket write permission; read/execute +// bits grant no sending authority. Directory ancestry is separately held and +// verified. Neither group nor other may write this daemon-owned socket. +fn protected_server_socket(socket: Identity, uid: u32, gid: u32) -> bool { + socket.mode & libc::S_IFMT == libc::S_IFSOCK + && socket.links == 1 + && socket.uid == uid + && socket.gid == gid + && socket.mode & 0o022 == 0 +} + /// Root-only source broker primitive. No daemon discovery, adoption, commands, /// configurable endpoint, retry, IP transport or time-setting entrypoint. pub struct NativeTimeSource { @@ -698,11 +709,11 @@ impl NativeTimeSource { )?; let server_identity = socket_identity(server_dir.as_raw_fd(), "chronyd.sock")?; ensure!( - server_identity.mode & libc::S_IFMT == libc::S_IFSOCK - && server_identity.links == 1 - && server_identity.uid == daemon.pin.daemon_uid - && server_identity.gid == daemon.pin.daemon_gid - && server_identity.mode & 0o007 == 0, + protected_server_socket( + server_identity, + daemon.pin.daemon_uid, + daemon.pin.daemon_gid, + ), "TIME_CHRONY_SOCKET_PROTECTION" ); Ok(Self { @@ -854,6 +865,21 @@ mod tests { .unwrap(); let old = UnixDatagram::bind(path.join("own.sock")).unwrap(); let expected = socket_identity(dir.as_raw_fd(), "own.sock").unwrap(); + let server = Identity { + mode: libc::S_IFSOCK | 0o755, + ..expected + }; + assert!(protected_server_socket(server, server.uid, server.gid)); + for mode in [0o775, 0o757] { + assert!(!protected_server_socket( + Identity { + mode: libc::S_IFSOCK | mode, + ..server + }, + server.uid, + server.gid, + )); + } std::fs::rename(path.join("own.sock"), path.join("held.sock")).unwrap(); let new = UnixDatagram::bind(path.join("own.sock")).unwrap(); assert!(unlink_owned(dir.as_raw_fd(), "own.sock", expected).is_err()); diff --git a/deploy/server_time_source_bootstrap.py b/deploy/server_time_source_bootstrap.py index c81f721..fc7286c 100644 --- a/deploy/server_time_source_bootstrap.py +++ b/deploy/server_time_source_bootstrap.py @@ -480,7 +480,7 @@ def chrony_observation(): directory = os.open('/run/chrony', os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW) dir_identity = fd_metadata(directory) require(stat.S_ISDIR(dir_identity['mode']) and dir_identity['uid'] == 989 and - dir_identity['gid'] == 989 and stat.S_IMODE(dir_identity['mode']) == 0o755, + dir_identity['gid'] == 989 and stat.S_IMODE(dir_identity['mode']) == 0o700, 'actual fixed protected Chrony socket directory') pidfile = os.open('chronyd.pid', os.O_RDONLY | os.O_NOFOLLOW, dir_fd=directory) pid_identity = fd_metadata(pidfile) diff --git a/deploy/time_source_socket_linux_acceptance.py b/deploy/time_source_socket_linux_acceptance.py new file mode 100644 index 0000000..b2526f4 --- /dev/null +++ b/deploy/time_source_socket_linux_acceptance.py @@ -0,0 +1,309 @@ +#!/usr/bin/env python3 +"""Frozen four Linux source units only; no actual Chrony or kernel query; no updater service or Apply. + +Prepare copies the independently reviewed snapshot locally. Execute is one +root-only Cloud-VM fixture run. After any lost reply read the original case; +never execute it again or substitute another binary/source generation. +""" +import argparse +import base64 +import hashlib +import inspect +import json +import os +from pathlib import Path +import stat +import uuid + +import windows_msi_runtime_acceptance as support + +ROOT = Path(__file__).resolve().parents[1] +ACCESS_ROOT = ROOT.parent / 'rust-discovery' +QUALIFICATION = ROOT / 'devstate/time-source-qualification/7a8cb5be-41b3-400a-bd9b-b4b6f505a6e9' +STATE = ROOT / 'devstate/time-source-socket-native-linux' +PROFILE = 'rmm.time-source.four-socket-permission-units.v1' +RECEIPT_SHA = '74759e286ba7c9762fe4c455da952a0e62de48f55ea643e0a8f435d2128497a5' +INPUTS_SHA = 'c0067889fa6e79e5b1dc2ad46685613fd0b379b30a4541670f635140405718d9' +BINARY_SHA = '9bd41ff166aeaae45fdf3dda2d72b04fc30e5ef87a181fe733c47e511a836d59' +BINARY_BYTES = 1169800 +TESTS = sorted(['native::tests::clock_brackets_reject_suspend_step_backwards_and_total_timeout', 'native::tests::socket_cleanup_preserves_replaced_name_and_removes_only_exact_own_inode', 'tracking::tests::exact_packet_sequence_and_network_source', 'tracking::tests::signed_float_ceil_and_overflow_are_conservative']) +AGENT_SHA = '0a7ad6eefaefda79ee80b6a41b2df904e9e7f50ae6ebeed01b98c25b6ce5c06f' +HELPER_SHA = '79442727c3ba31cda02a8bc0e67481f14db9f39fc07520a880a90b64f10f1eaf' + + +def sha(raw): + return hashlib.sha256(raw).hexdigest() + + +def save_local(path, value): + support.save(path, value) + fd = os.open(path.parent, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW) + try: + os.fsync(fd) + finally: + os.close(fd) + + +def copy_exact(source, destination, digest, size): + metadata = source.lstat() + support.require(stat.S_ISREG(metadata.st_mode) and metadata.st_nlink == 1 + and metadata.st_uid in (0, os.getuid()) and not metadata.st_mode & 0o002 + and metadata.st_size == size and size <= 2 * 1024 * 1024, 'bounded regular frozen input') + raw = source.read_bytes() + support.require(sha(raw) == digest, 'frozen snapshot input hash') + destination.parent.mkdir(mode=0o700, parents=True, exist_ok=True) + support.private(destination.parent, True) + fd = os.open(destination, os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW | os.O_WRONLY, 0o600) + with os.fdopen(fd, 'wb') as stream: + stream.write(raw); stream.flush(); os.fsync(stream.fileno()) + fd = os.open(destination.parent, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW) + try: + os.fsync(fd) + finally: + os.close(fd) + + +def verify_case(folder): + value = support.load(folder / 'manifest.json') + support.require(value['profile'] == PROFILE and value['tests'] == TESTS + and value['runner_sha256'] == sha(Path(__file__).read_bytes()) + and value['receipt_sha256'] == RECEIPT_SHA and value['binary_sha256'] == BINARY_SHA + and value['binary_bytes'] == BINARY_BYTES, 'same original reviewed manifest') + support.require(sha((folder / 'receipt.json').read_bytes()) == RECEIPT_SHA + and sha((folder / 'inputs.json').read_bytes()) == INPUTS_SHA, 'original qualification provenance') + source = support.load(folder / 'inputs.json') + support.require(len(source) == 7 and source == value['source_files'], 'exact frozen seven provider inputs') + for item in source: + path = Path(item['path']) + support.require(not path.is_absolute() and '..' not in path.parts, 'fixed snapshot relative path') + file = folder / 'source' / path + support.private(file) + support.require(file.stat().st_size == item['bytes'] and sha(file.read_bytes()) == item['sha256'], 'retained source freeze') + binary = folder / 'time-contract-tests'; support.private(binary) + support.require(binary.stat().st_size == BINARY_BYTES and sha(binary.read_bytes()) == BINARY_SHA, 'original qualified test bytes') + for path, digest in value['transport_sources'].items(): + support.require(sha((ROOT / path).read_bytes()) == digest, 'original strict transport source') + return value + + +def remote(p): + import base64 + import hashlib + import json + import os + from pathlib import Path + import selectors + import signal + import stat + import subprocess + import time + import uuid + + def require(ok, message): + if not ok: + raise RuntimeError(message) + + def enc(value): + return json.dumps(value, sort_keys=True, separators=(',', ':')).encode() + + def create(path, raw, mode=0o600): + fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, mode) + with os.fdopen(fd, 'wb') as stream: + stream.write(raw); stream.flush(); os.fsync(stream.fileno()) + fd = os.open(path.parent, os.O_DIRECTORY | os.O_RDONLY | os.O_NOFOLLOW) + try: + os.fsync(fd) + finally: + os.close(fd) + + def run(args, timeout=20): + # Keep the owned group leader unreaped until its entire group has been + # cleaned up. Its PID therefore cannot be recycled before killpg. + child = subprocess.Popen(args, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, + stderr=subprocess.PIPE, start_new_session=True, + env={'PATH': '/usr/bin:/bin', 'LC_ALL': 'C', 'HOME': '/nonexistent'}) + selector = selectors.DefaultSelector() + buffers = {'stdout': bytearray(), 'stderr': bytearray()} + deadline = time.monotonic() + timeout + try: + for stream, name in ((child.stdout, 'stdout'), (child.stderr, 'stderr')): + os.set_blocking(stream.fileno(), False); selector.register(stream, selectors.EVENT_READ, name) + while True: + require(time.monotonic() < deadline, 'owned native command timeout; read original case only') + for key, _ in selector.select(0.02): + raw = os.read(key.fileobj.fileno(), 4096) + if raw: + buffers[key.data].extend(raw) + require(len(buffers[key.data]) <= 65536, 'bounded native output') + else: + selector.unregister(key.fileobj) + ended = os.waitid(os.P_PID, child.pid, os.WEXITED | os.WNOHANG | os.WNOWAIT) + if ended is not None: + # Child remains a zombie until finally: no PID/group reuse. + os.killpg(child.pid, signal.SIGKILL) + for key in list(selector.get_map().values()): + while True: + try: + raw = os.read(key.fileobj.fileno(), 4096) + except BlockingIOError: + break + if not raw: + break + buffers[key.data].extend(raw) + require(len(buffers[key.data]) <= 65536, 'bounded native output') + code = ended.si_status if ended.si_code == os.CLD_EXITED else -ended.si_status + return code, bytes(buffers['stdout']), bytes(buffers['stderr']) + finally: + os.killpg(child.pid, signal.SIGKILL) + child.wait() + selector.close(); child.stdout.close(); child.stderr.close() + + def metadata_identity(value): + return (value.st_dev, value.st_ino, value.st_uid, value.st_gid, value.st_mode, + value.st_nlink, value.st_size, value.st_mtime_ns, value.st_ctime_ns) + + def hashed(path, maximum, process_image=False): + fd = os.open(path, os.O_RDONLY | os.O_CLOEXEC | (0 if process_image else os.O_NOFOLLOW)) + with os.fdopen(fd, 'rb') as stream: + before = os.fstat(stream.fileno()); require(stat.S_ISREG(before.st_mode) and before.st_size <= maximum, 'bounded witness file') + digest = hashlib.sha256(); total = 0 + while True: + raw = stream.read(32768) + if not raw: + break + total += len(raw); require(total <= maximum, 'bounded witness hash'); digest.update(raw) + after = os.fstat(stream.fileno()) + require(metadata_identity(before) == metadata_identity(after) and total == before.st_size, 'stable witness hash') + return before, digest.hexdigest() + + def witness(): + out = {'boot_id': Path('/proc/sys/kernel/random/boot_id').read_text().strip(), 'services': {}, 'files': {}} + release = dict(line.split('=', 1) for line in Path('/etc/os-release').read_text().splitlines() if '=' in line) + require(release.get('ID', '').strip('"') == 'ubuntu' and release.get('VERSION_ID', '').strip('"') == '24.04', 'fixed native Ubuntu24.04') + out['os'] = {'id': 'ubuntu', 'version': '24.04', 'machine': os.uname().machine, 'kernel': os.uname().release} + for name, uid, binary in ( + ('rmm-agent-remote.service', 993, p['agent_sha256']), + ('rmm-helper-cloud.service', 0, p['helper_sha256']), + ('rmm-full-maintenance-helper.service', 0, p['helper_sha256'])): + code, stdout, _ = run(['/usr/bin/systemctl', 'show', name, '-p', 'ActiveState', '-p', 'MainPID', '-p', 'UnitFileState', '-p', 'InvocationID']) + require(code == 0, 'existing service read') + service = dict(line.split('=', 1) for line in stdout.decode().splitlines()) + pid = int(service['MainPID']); require(service['ActiveState'] == 'active' and pid > 1, 'three existing services active') + proc = Path('/proc', str(pid)); birth = (proc / 'stat').read_text().rsplit(') ', 1)[1].split()[19] + ids = {line.split(':')[0]: line.split()[1:] for line in (proc / 'status').read_text().splitlines() if line.startswith(('Uid:', 'Gid:'))} + metadata, image = hashed(proc / 'exe', 256 * 1024 * 1024, process_image=True) + current = (proc / 'exe').stat() + require(ids['Uid'] == [str(uid)] * 4 and ids['Gid'] == ['984'] * 4 and image == binary + and (metadata.st_dev, metadata.st_ino) == (current.st_dev, current.st_ino) + and (proc / 'stat').read_text().rsplit(') ', 1)[1].split()[19] == birth, 'current generation/account/image') + out['services'][name] = dict(service, birth=birth, image=image, ids=ids) + code, stdout, _ = run(['/usr/bin/systemctl', 'show', 'rmm-apt-helper.service', '-p', 'ActiveState', '-p', 'UnitFileState']) + apt = dict(line.split('=', 1) for line in stdout.decode().splitlines()) + require(code == 0 and apt == {'ActiveState': 'inactive', 'UnitFileState': 'disabled'}, 'APT remains closed') + out['apt'] = apt + for name in ('/etc/rmm-remote/helper-general.json', '/etc/rmm-remote/helper-full-maintenance.json', + '/etc/rmm-remote/full-maintenance-helper-proof.json', '/etc/systemd/system/rmm-full-maintenance-helper.service'): + path = Path(name); metadata = path.lstat() + require(not path.is_symlink() and stat.S_ISREG(metadata.st_mode) and metadata.st_uid == 0 + and not metadata.st_mode & 0o022 and metadata.st_nlink == 1, 'protected known control') + current, digest = hashed(path, 65536) + require(metadata_identity(current) == metadata_identity(metadata), 'same known control file') + out['files'][name] = [metadata.st_dev, metadata.st_ino, metadata.st_uid, metadata.st_gid, metadata.st_mode, + metadata.st_size, metadata.st_mtime_ns, metadata.st_ctime_ns, digest] + for name in ('/var/lib/rmm-helper/consumption.sqlite', '/var/lib/rmm-helper/executor.lock', + '/var/lib/rmm-agent-remote/journal.sqlite', '/var/lib/rmm-agent-remote/consumption.sqlite'): + path = Path(name); metadata = path.lstat() + require(not path.is_symlink() and stat.S_ISREG(metadata.st_mode) and metadata.st_nlink == 1, 'existing state identity') + out['files'][name] = [metadata.st_dev, metadata.st_ino, metadata.st_uid, metadata.st_gid, metadata.st_mode] + return out + + require(os.geteuid() == 0 and os.uname().machine == 'x86_64', 'fixed Cloud Linux root contract fixtures') + ident = str(uuid.UUID(p['id'])); require(ident == p['id'], 'canonical original case') + folder = Path('/var/tmp') / ('rmm-time-source-units-linux-' + ident) + if p['action'] == 'read': + metadata = folder.lstat() + require(stat.S_ISDIR(metadata.st_mode) and not folder.is_symlink() and metadata.st_uid == 0 + and stat.S_IMODE(metadata.st_mode) == 0o700, 'own original case only') + result = folder / 'result.json' + return {'read_only': True, 'id': ident, 'entered': (folder / 'entered.json').exists(), + 'result': json.loads(result.read_bytes()) if result.exists() else None, 'current_witness': witness()} + require(p['action'] == 'execute', 'one fixed time contract action') + os.umask(0o077); folder.mkdir(mode=0o700) + create(folder / 'intent.json', enc({key: value for key, value in p.items() if key != 'binary_b64'})) + require(len(p['binary_b64']) == 1559736, 'bounded binary transfer') + raw = base64.b64decode(p['binary_b64'], validate=True) + require(len(raw) == 1169800 and hashlib.sha256(raw).hexdigest() == p['binary_sha256'], 'fixed four-unit binary') + binary = folder / 'time-contract-tests'; create(binary, raw, 0o700) + before = witness(); create(folder / 'before.json', enc(before)) + command = ['/usr/bin/setpriv', '--reuid=0', '--regid=0', '--clear-groups', '--no-new-privs', str(binary)] + code, stdout, stderr = run(command + ['--list', '--format', 'terse']) + create(folder / 'list.stdout', stdout); create(folder / 'list.stderr', stderr) + require(code == 0 and stderr == b'', 'native list succeeded') + lines = stdout.decode().splitlines() + require(len(lines) == 4 and sorted(line[:-6] for line in lines if line.endswith(': test')) == p['tests'], 'exact four tests before any run') + create(folder / 'entered.json', enc({'id': ident, 'run_once': True, 'time_ns': time.time_ns()})) + code, stdout, stderr = run(command + ['--test-threads=1', '--nocapture']) + create(folder / 'run.stdout', stdout); create(folder / 'run.stderr', stderr) + after = witness(); create(folder / 'after.json', enc(after)) + require(before == after and code == 0 and stderr == b'' + and b'4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out' in stdout + and all((b'test ' + name.encode() + b' ... ok') in stdout for name in p['tests']), 'four native units and retained target state') + receipt = dict(id=ident, profile=p['profile'], passed=4, ignored=0, filtered=0, execution_uid=0, tests=p['tests'], + before=before, after=after, binary_sha256=p['binary_sha256'], source_receipt_sha256=p['receipt_sha256'], + source_manifest_sha256=p['manifest_sha256'], stdout_sha256=hashlib.sha256(stdout).hexdigest(), + no_rmm_jobs=True, no_apply=True, no_service_control=True) + create(folder / 'result.json', enc(receipt)); return receipt + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('action', choices=('prepare', 'execute', 'read')); parser.add_argument('--case') + args = parser.parse_args(); os.umask(0o077) + STATE.mkdir(mode=0o700, parents=True, exist_ok=True); support.private(STATE, True) + if args.action == 'prepare': + support.require(args.case is None, 'prepare one new local case') + receipt_path = QUALIFICATION / 'receipt.json'; support.private(receipt_path) + support.require(sha(receipt_path.read_bytes()) == RECEIPT_SHA, 'independently reviewed source receipt') + receipt = support.load(receipt_path); original = support.load(QUALIFICATION / 'inputs.json') + support.require(sha((QUALIFICATION / 'inputs.json').read_bytes()) == INPUTS_SHA + and receipt['inputs_sha256'] == INPUTS_SHA and len(original) == 7 + and receipt['result'] == 'LOCAL_RELEASE_PROVIDER4_SOCKET_PERMISSION_FIX_PASS' and receipt['tests'] == 4 + and receipt['skips'] == 0 and receipt['filters'] == 0, 'reviewed four-test qualification') + ident = str(uuid.uuid4()); folder = STATE / ident; folder.mkdir(mode=0o700) + copy_exact(receipt_path, folder / 'receipt.json', RECEIPT_SHA, receipt_path.stat().st_size) + copy_exact(QUALIFICATION / 'inputs.json', folder / 'inputs.json', INPUTS_SHA, (QUALIFICATION / 'inputs.json').stat().st_size) + paths = set() + for item in original: + path = Path(item['path']) + support.require(not path.is_absolute() and '..' not in path.parts and str(path) not in paths, 'unique fixed frozen input') + paths.add(str(path)); copy_exact(QUALIFICATION / 'source' / path, folder / 'source' / path, item['sha256'], item['bytes']) + binary = QUALIFICATION / 'qualified-provider-tests' + support.require(receipt['artifacts'][0] == dict(path='qualified-provider-tests', bytes=BINARY_BYTES, sha256=BINARY_SHA), 'fixed original linked artifact') + copy_exact(binary, folder / 'time-contract-tests', BINARY_SHA, BINARY_BYTES) + transports = {path: sha((ROOT / path).read_bytes()) for path in ('deploy/windows_msi_runtime_acceptance.py', 'deploy/vm_access_check.py')} + save_local(folder / 'manifest.json', dict(id=ident, profile=PROFILE, runner_sha256=sha(Path(__file__).read_bytes()), + receipt_sha256=RECEIPT_SHA, binary_sha256=BINARY_SHA, binary_bytes=BINARY_BYTES, + source_files=original, tests=TESTS, transport_sources=transports)) + verify_case(folder) + print(json.dumps({'id': ident, 'prepared_locally': True})); return + support.require(args.case is not None, 'original --case required') + ident = str(uuid.UUID(args.case)); support.require(ident == args.case, 'same canonical original case') + folder = STATE / ident; support.private(folder, True); verify_case(folder) + payload = dict(id=ident, action=args.action, profile=PROFILE, tests=TESTS, binary_sha256=BINARY_SHA, + receipt_sha256=RECEIPT_SHA, manifest_sha256=sha((folder / 'manifest.json').read_bytes()), + agent_sha256=AGENT_SHA, helper_sha256=HELPER_SHA) + if args.action == 'execute': + save_local(folder / 'execute-entered.json', {'once': True, 'no_retry': True}) + payload['binary_b64'] = base64.b64encode((folder / 'time-contract-tests').read_bytes()).decode() + code = 'import json\n' + inspect.getsource(remote) + '\nprint(json.dumps(remote(' + repr(payload) + ')))\n' + response = support.transport(support.access_settings(ACCESS_ROOT, 'linux'), 'python3 -', code.encode(), folder) + save_local(folder / (args.action + '-' + str(uuid.uuid4()) + '.json'), response) + if args.action == 'read' and response['result'] is not None: + support.require(response['result']['source_manifest_sha256'] == sha((folder / 'manifest.json').read_bytes()) + and response['current_witness'] == response['result']['after'], 'same-case retained native result') + print(json.dumps({'id': ident, 'action': args.action, 'passed': response.get('passed'), + 'complete': response.get('result') is not None if args.action == 'read' else True, 'read_only': args.action == 'read'})) + + +if __name__ == '__main__': + main() diff --git a/docs/handover.md b/docs/handover.md index 26fa487..ff2d64d 100644 --- a/docs/handover.md +++ b/docs/handover.md @@ -1,5 +1,12 @@ # Übergabe — Linux-MVP abgeschlossen, Windows wird fortgesetzt +**Provider-Socketfix Linux-first bestanden:** Originalfall8ee39b4f, native +Cloud-Linux4/4 ohne Skip/Filter, separater Originalread vollständig; bekannte +Runtimezeugen erhalten.0755 akzeptiert, Gruppen-/Fremdwrite verweigert, +Ancestry/Socket-/Daemon-/Credentialbindung erhalten. [Ergebnis](server-time-source.md). +Keine Chronyrechte geändert und noch keine echte Serverqualitätsprobe. + + **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. diff --git a/docs/server-time-source-bootstrap.md b/docs/server-time-source-bootstrap.md index 99eabd8..69ba67d 100644 --- a/docs/server-time-source-bootstrap.md +++ b/docs/server-time-source-bootstrap.md @@ -108,8 +108,8 @@ exakt drei tatsächlichen Prozesse seiner festen Cgroup Chronyd-Kind. Keine zusätzliche oder untergeordnete Cgroup wird übergangen. Beide Chronyd-Prozesse müssen UID/GID989 und dieselben geschützten `/usr/sbin/chronyd`-Originalbytes besitzen. Der Root:Root0644-single-link-Pidfile -`/run/chrony/chronyd.pid` bestimmt den Daemon; weil das Verzeichnis UID/GID989 -gehört, reicht diese Datei allein ausdrücklich nicht als Namensautorität. +`/run/chrony/chronyd.pid` bestimmt den Daemon; weil das Verzeichnis UID/GID989 und Modus0700 +besitzt, reicht diese Datei allein ausdrücklich nicht als Namensautorität. Zusätzlich muss unter diesen drei Prozessen ausschließlich genau der gewählte Daemon den tatsächlichen Kernelinode des festen Unix-Datagramsockets `/run/chrony/chronyd.sock` halten. Diese begrenzte Beobachtung behauptet keine @@ -301,3 +301,16 @@ werden: der Dateiname `operator.py` darf keine gleichnamigen Python-Standardmodu gespeichert; unerwartete Fehler liefern nur `unexpected_operator_exception`, keinen Exceptiontext oder Traceback. Verlorene Antworten erlauben ausschließlich Lesen des ursprünglichen Falls, keine Phasenwiederholung oder Pinheilung. + + +Der nachfolgende tatsächliche Preflightfall +`053cfe86` verweigerte allein die zuvor fälschlich erwartete +Chronyverzeichnisberechtigung0755. Der lesende Originalbeleg +`22fa2aabdfdbbd0fe55957358f7f651f317ee647b20a46ab1f2613a365095d7f` +zeigt UID/GID9890700 für `/run/chrony`, Root:Root0644 mit einem Link für die +Pidfile und UID/GID9890755 mit einem Link für den Socket. Der Operator verlangt +jetzt exakt das beobachtete Verzeichnis0700. Der Provider akzeptiert am Socket +Lese-/Ausführungsbits, verweigert weiterhin Gruppen-/Fremdschreibrechte und +behält alle Identitäts-, Ancestry- und Kernelcredentialprüfungen bei. Es wurden +keine Chronyberechtigungen geändert. Beide fehlgeschlagenen Originalfälle bleiben +erhalten; diese Quelle benötigt erneut einen neuen Paket-/Abnahmefall. diff --git a/docs/server-time-source.md b/docs/server-time-source.md index 49ac684..70f9bf8 100644 --- a/docs/server-time-source.md +++ b/docs/server-time-source.md @@ -50,8 +50,13 @@ würdigen Pin separat provisionieren und die Providerinstanz neu eröffnen. Ziel ist ausschließlich `/run/chrony/chronyd.sock`. Seine Identität und Verzeichniskette werden vor und nach der Abfrage geprüft. Nicht-root-eigene Verzeichnisse müssen dem gepinnten Chrony-Konto gehören; kein Gruppen- oder -Fremdschreibrecht. Der Socket muss dem gepinnten Daemonkonto gehören und darf -keine Rechte für Fremde haben. Andere Images oder Layouts bleiben vorerst +Fremdschreibrecht. Der Socket muss ein einzelner Socketinode des gepinnten Daemonkontos sein +und darf weder Gruppen- noch Fremdschreibrecht haben. Lese-/Ausführungsbits +wie beim tatsächlich beobachteten Modus0755 verleihen auf Linux kein Recht, +ein Datagramm zu senden; dafür ist Schreibrecht am Pathnamesocket erforderlich +([Linux unix(7)](https://man7.org/linux/man-pages/man7/unix.7.html)). Der Server +verwendet tatsächlich das gehaltene Chronyverzeichnis UID/GID9890700; dessen +Identität sowie sämtliche übrigen Ancestry-/Credentialprüfungen bleiben Pflicht. Andere Images oder Layouts bleiben vorerst nicht unterstützt, ohne permissiven Fallback. Der vom Rootoperator separat anzulegende Clientbereich ist @@ -210,3 +215,37 @@ Socket-Fixtures einschließlich tatsächlicher Namenersetzung/FD-Cleanup. diesem Lauf.** Der neue native OS-/Validatornachweis ersetzt nicht die offene reale ARM64-Serverprobe mit provisioniertem Pin und frischer gemeinsamer Chrony-/Kernelqualität. + +## Tatsächlich nativ: Socketberechtigungsfix auf Cloud-Linux + +2026-11-15, Originalfall `8ee39b4f-daed-4953-b90f-c04a7b2857c1`: +alle vier vollständig gelisteten Provider-Vertragsprüfungen auf der +tatsächlichen Cloud-Linux-VM als UID0 bestanden,0 fehlgeschlagen,0 ignoriert, +0 gefiltert. Separater Originalfall-Readback vollständig; bekannte Runtimezeugen +vorher/nachher/aktuell unverändert. Der bestehende Sockettest enthält jetzt +ausdrücklich0755 positiv sowie0775/0757 negativ. Root-/Daemonidentitäten, +gehaltene Verzeichnis-/Socketinodes, Singlelink und SCM-Credentials werden +nicht durch eine Berechtigungsausnahme ersetzt. Auf dem Server wurde keine +Chrony-Datei oder -Berechtigung geändert. + +Qualifizierte Nativequelle-SHA256 +`f1fede6a260c4f91c4bf647f2dcadb63520cdadff22c0130327ecd7cae57921b`. +Lokale eingefrorene Releasequalification7a8cb5be-41b3-400a-bd9b-b4b6f505a6e9, +Receipt-SHA256 +`74759e286ba7c9762fe4c455da952a0e62de48f55ea643e0a8f435d2128497a5`, +Sieben-Inputmanifest +`c0067889fa6e79e5b1dc2ad46685613fd0b379b30a4541670f635140405718d9`. +Diese Inputs enthalten auch die zum Freezezeitpunkt gesicherte Dokumentfassung; +nachfolgende Ergebnisdokumentation ist kein Compilerinput. ELF1169800Bytes, +SHA256 `9bd41ff166aeaae45fdf3dda2d72b04fc30e5ef87a181fe733c47e511a836d59`. +Neuer Operator `deploy/time_source_socket_linux_acceptance.py`, SHA256 +`eef43096cac8a83751f844d810b97a3f68025786ca64ff34f82be59280ca1aa8`. + +Der Lauf verwendet eigene Parser-/Clock-/Socketfixtures. Er öffnet keine +echte NativeTimeSource, fragt weder tatsächliches Chrony noch die Kernelzeit +ab und qualifiziert keinen signierten Zeitanker oder Windowsclock. Reale +Serverprobe und nachfolgender Broker-/mTLS-Roundtrip bleiben offene Schritte. + +Ausführungsreceipt-SHA256 `0decb992bfbfa88389da1949fddb491f2ec02a30abc9f4cce886d1f645768e07`. + +Separater Rückabruf-SHA256 `88728b6659d506ba96140dd1924a089969e63fcd6f6d308109c4603ec4043da8`.