Merge commit '8bee0ad'
Rust development slice / linux (push) Failing after 6s

This commit is contained in:
2026-11-15 15:54:07 +01:00
3 changed files with 732 additions and 0 deletions
+103
View File
@@ -0,0 +1,103 @@
"""Local contract fixtures only; no native qualification or target calls."""
import base64
import copy
import json
import tempfile
import unittest
from pathlib import Path
from unittest.mock import patch
import time_profile_config as t
from vm_mvp_acceptance import GuardError
def fixture():
binding = {'tenant_id':'11111111-1111-4111-8111-111111111111',
'agent_id':'22222222-2222-4222-8222-222222222222',
'asset_id':'33333333-3333-4333-8333-333333333333',
'enrollment_generation':1,'assignment_version':1,'public_key_hex':'11'*32}
public = {'public-binding.json':binding,'qualified-time-public-key.json':{
'key_generation':1,'server_instance':'44444444-4444-4444-8444-444444444444',
'key_id':'local_fixture_only','public_key_hex':'22'*32},'public-platform.json':{'fixture_only':True}}
agent_sid = 'S-1-5-80-1-2-3-4-5';helper_sid = 'S-1-5-80-1-2-3-4-6'
result = {'id':'55555555-5555-4555-8555-555555555555','verified':True,'completed':True,
'no_jobs':True,'windows_jobs_enabled':False,'helper_effects_enabled':False,
'clock_adapter_qualified':False,'private_key_read':False}
native = dict(agent_id=binding['agent_id'],asset_id=binding['asset_id'],
binary_sha256=t.IMAGES['agent'],helper_sha256=t.IMAGES['system_helper'],
policy_sha256='a'*64,pin_sha256='b'*64,files={})
for role, service, kernel, label, user, image in (
('agent','service','agent_kernel','agent','S-1-5-19','rmm-agent-windows.exe'),
('system_helper','helper_service','helper_kernel','helper','S-1-5-18','rmm-helper-windows.exe')):
native[service] = dict(state='Running',pid=42,creation_filetime='123',owner_sid=user)
native[kernel] = dict(pid=42,creation_filetime='123',owner_sid=user,service_sid=agent_sid if role=='agent' else helper_sid,
kernel_handle_bound=True,service_sid_enabled=True,
image='C:\\Program Files\\RustDiscovery\\'+image)
native['files'][label] = dict(file_id='a'*32,sha256=t.IMAGES[role])
result['native'] = native
settings = dict(binding=binding,enable_effects=False,agent=dict(service_sid=agent_sid),helper=dict(service_sid=helper_sid))
payload = dict(new_agent=t.IMAGES['agent'],new_helper=t.IMAGES['system_helper'],
new_policy='a'*64,new_pin='b'*64,qualification_sha256=t.LINK_RECEIPT,
manifest_sha256=t.LINK_RECEIPT,settings_base64=base64.b64encode(t.canonical(settings)).decode())
return public,result,payload,{'local-service':{'fixture_only':True},'system':{'fixture_only':True}}
class PublicProfileContract(unittest.TestCase):
def setUp(self):
self.values = fixture()
self.pair = patch.object(t,'PAIR_ID',self.values[1]['id']);self.pair.start();self.addCleanup(self.pair.stop)
def render(self, values=None):
return t.produce(*(values or self.values),'c'*64,'d'*64)[0]
def test_v2_fixture_links_both_exact_roles_without_runtime_success(self):
items = self.render();config=json.loads(items['time-attestation.json'])
self.assertEqual(config['schema_version'],2)
self.assertNotIn('base_error_ns',config)
for role in config['trusted_os_active_guest']['qualifications']:
raw=items[role['role']+'-qualification.json'];value=json.loads(raw)
self.assertEqual(t.sha(raw),role['qualification_sha256'])
self.assertFalse(value['signed_runtime_verified']);self.assertFalse(value['physical_calibration_claimed'])
self.assertEqual(value['source_sha256'],t.SOURCE_SHA if role['role']=='agent' else t.ORIGINAL_SOURCE_SHA)
def test_missing_or_not_completed_actual_pair_is_denied(self):
for field in ('verified','completed','no_jobs'):
values=copy.deepcopy(self.values);values[1].pop(field)
with self.assertRaises(GuardError):self.render(values)
def test_wrong_kernel_birth_account_sid_image_or_fileid_is_denied(self):
for field,value in [('creation_filetime','124'),('owner_sid','S-1-5-18'),
('service_sid_enabled',False),('kernel_handle_bound',False),
('service_sid','S-1-5-18'),('image','C:\\wrong.exe')]:
values=copy.deepcopy(self.values);values[1]['native']['agent_kernel'][field]=value
with self.assertRaises(GuardError):self.render(values)
values=copy.deepcopy(self.values);values[1]['native']['files']['agent']['file_id']='bad'
with self.assertRaises(GuardError):self.render(values)
def test_image_build_policy_and_identity_drift_is_denied(self):
for field in ('new_agent','new_helper','new_policy','new_pin','qualification_sha256','manifest_sha256'):
values=copy.deepcopy(self.values);values[2][field]='0'*64
with self.assertRaises(GuardError):self.render(values)
values=copy.deepcopy(self.values);values[0]['public-binding.json']['agent_id']='99999999-9999-4999-8999-999999999999'
with self.assertRaises(GuardError):self.render(values)
def test_no_actual_pair_pins_blocks_before_creating_any_case(self):
with tempfile.TemporaryDirectory() as root, patch.object(t,'STATE',Path(root)/'absent'),patch.object(t,'PAIR_ID',None):
with self.assertRaises(GuardError):t.prepare()
self.assertFalse(t.STATE.exists())
def test_bounded_nofollow_read_duplicate_json_and_createonce(self):
with tempfile.TemporaryDirectory() as root:
path=Path(root)/'value.json';t.write(path,b'{"a":1}\n')
self.assertEqual(t.read(path)[1],{'a':1})
with self.assertRaises(FileExistsError):t.write(path,b'{}')
with self.assertRaises(GuardError):t.read(path,'0'*64)
link=Path(root)/'link';link.symlink_to(path)
with self.assertRaises(OSError):t.read(link)
bad=Path(root)/'duplicate.json';t.write(bad,b'{"a":1,"a":2}')
with self.assertRaises(GuardError):t.read(bad)
with self.assertRaises(GuardError):t.read(path,limit=1)
if __name__ == '__main__':
unittest.main()
+509
View File
@@ -0,0 +1,509 @@
#!/usr/bin/env python3
"""First public V2 time pin for one actual qualified Windows product pair.
prepare/guards are local only. No target operation happens on import.
Missing native product-role/readback evidence blocks preparation; diagnostics
are never relabelled as calibrated product clocks or signed runtime success.
"""
import argparse
import base64
import copy
import hashlib
import json
import os
from pathlib import Path
import re
import stat
import uuid
import system_pipe_upgrade as prior
import signed_clock_capture_acceptance as raw_capture
ROOT = Path(__file__).resolve().parents[2]
CLOCK = ROOT.parent / 'rust-discovery-signed-clock'
MAIN = ROOT.parent / 'rust-discovery'
STATE = ROOT / 'devstate/windows-time-profile-config'
PUBLIC = CLOCK / 'devstate/windows-time-profile-public-preparation/c3077acf-12da-410e-9f55-e75a1cd0a75f'
PAIR_ID = None # Root binds the actual new single passive pair case after qualification.
PAIR_RESULT_SHA = None
PAIR_INTENT_SHA = None
PAIR_ROOT = CLOCK / 'devstate/windows-signed-clock/passive-pair-upgrade'
SOURCE_CASE = CLOCK / 'devstate/windows-signed-clock/trusted-os-qualification-c4679433-b632-4d6e-8668-f0f2fb54a542'
LINK_CASE = MAIN / 'devstate/windows-client/operator-window-20261115/observed-agent-build'
ORIGINAL_SOURCE_SHA = 'd8594c1eba2c2cc5d5fde4a462b2110aa2e7e64081452b742c4ed81a2cfb477d'
SOURCE_SHA = '342494c4f9e7eca439c059745591a8e907026da20f56b223fcb0eb0707aa6d82'
SOURCE_RECEIPT = '96b05fe13f4d459b4b3ef78292beea33827b1ea47293ffb5921c685940e82a4d'
LINK_RECEIPT = 'f04024f78c2f11f5c66bbdf9278467f5bcc50da5c2bd7336623851bca42dd446'
LINK_INPUTS = '11717fab51bd1d6bf103b1821cc1e2a84699f46cac21f2cc614acf4b68381fa4'
ORIGINAL_LINK_RECEIPT = '04ed34e6e850aca77c1fd4677ddb271f7ccd9492a97f5d4e00ead4c1f032f29d'
NATIVE_RESULTS = {
'linux': ('84592e7a-6554-4a7d-a73f-2bdebdb9e9a8', '150954b0ab290d8e9fbda5616f6df071168efd88a9f1d8b48b2bd8a5f5de7c20'),
'windows': ('44059065-c17e-43c3-86aa-d4d131454ccb', 'b235bdd444c112ff91cbc5f160d39d69ef79fb419b9b2ab7ccdcec06009d5c6b')}
ORIGINAL_IMAGES = {'agent': '26dc9d2f6928c5a41050ac9324e041c065e7a9ae52324416f3bb6222c002ae6b',
'system_helper': '59675a3cbb3a5d213fc764f38379d6b81baaf9d47a7124470cc2767d4985763e'}
IMAGES = {'agent': '0549d9ebea73cff996938f859b92192cc333de194128d7c6859a3f1d2e85893c',
'system_helper': ORIGINAL_IMAGES['system_helper']}
ASSUMPTION = 'active_guest_no_pause_save_restore_snapshot_migration_host_suspend'
PUBLIC_SHAS = {'qualified-time-public-key.json': 'c31d31d2d61f881d04f55f704abbbf98f4822650c016f39e39d4d2318bc3f6e2',
'public-platform.json': '94ae865e0e3449f6901f4d5f593aacbd5829b06340e296e19e6f0159a157cba3',
'public-binding.json': '9239ee9f4142735867e77451478bf309fbf449d730a0ede6c958bc8018830dde',
'input-provenance.json': '1c0db66cd0692024f68bddd71949692d274380a86e4b880fea0756479ceb5d0c',
'receipt.json': '97e4db147f31f3cff134d2bc596d7d73ea5330b8b5a87971f215bb03a9751391'}
RAW = CLOCK / 'devstate/windows-signed-clock-capture-completion/ccba6d8f-c58f-4d2d-a51c-1efb3bfbabdf'
RAW_RECEIPTS = {'local-service': '10dd411be265d018489bf9477747ce2d5846ac04128f583425aec4b3c9d5252b',
'system': '7409309ea6d586566373f570d6950c60ce2597cf939f261e6d2ea4def004a22f'}
require = prior.require
def sha(raw):
return hashlib.sha256(raw).hexdigest()
def canonical(value):
return (json.dumps(value, sort_keys=True, separators=(',', ':'), ensure_ascii=False) + '\n').encode()
def strict_object(items):
value = {}
for key, item in items:
require(key not in value, 'duplicate public JSON field')
value[key] = item
return value
def read(path, expected=None, limit=2*1024*1024, decode=True, public=False):
fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK)
with os.fdopen(fd, 'rb') as stream:
before = os.fstat(stream.fileno())
modes = (0o600,0o644,0o664) if public and expected is not None else (0o600,)
require(stat.S_ISREG(before.st_mode) and before.st_uid == os.getuid() and before.st_nlink == 1
and stat.S_IMODE(before.st_mode) in modes and 0 < before.st_size <= limit,
'private bounded actual public evidence')
raw = stream.read(limit + 1); after = os.fstat(stream.fileno())
require((before.st_dev,before.st_ino,before.st_size,before.st_mtime_ns,before.st_ctime_ns)
== (after.st_dev,after.st_ino,after.st_size,after.st_mtime_ns,after.st_ctime_ns)
and len(raw) == before.st_size and (expected is None or sha(raw) == expected),
'unchanged independently pinned public evidence')
return raw, json.loads(raw, object_pairs_hook=strict_object) if decode else None
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 public_inputs():
values = {name: read(PUBLIC/name,digest)[1] for name,digest in PUBLIC_SHAS.items()}
pin, platform, binding = (values[n] for n in ('qualified-time-public-key.json','public-platform.json','public-binding.json'))
require(set(pin) == {'algorithm','schema_version','key_generation','key_id','server_instance','public_key_hex'}
and pin['algorithm'] == 'Ed25519' and pin['schema_version'] == 1
and type(pin['key_generation']) is int and pin['key_generation'] > 0
and re.fullmatch('[A-Za-z0-9_-]{1,64}',pin['key_id'])
and re.fullmatch('[a-f0-9]{64}',pin['public_key_hex']), 'actual separate public time key')
require(str(uuid.UUID(pin['server_instance'])) == pin['server_instance'] and uuid.UUID(pin['server_instance']).int > 0,
'actual server instance')
require(set(binding) == {'tenant_id','asset_id','agent_id','enrollment_generation','assignment_version','public_key_hex'}
and all(str(uuid.UUID(binding[k])) == binding[k] and uuid.UUID(binding[k]).int > 0 for k in ('tenant_id','asset_id','agent_id'))
and type(binding['enrollment_generation']) is int and binding['enrollment_generation'] == 1
and type(binding['assignment_version']) is int and binding['assignment_version'] == 1
and bytes.fromhex(pin['public_key_hex']) != bytes.fromhex(binding['public_key_hex']), 'unchanged actual identity and distinct time/job keys')
require(platform['schema'] == 1 and platform['hypervisor'] == 'kvm' and platform['state'] == 'running'
and platform['domain_uuid'] == '1ec0d319-24bc-4953-a6b2-52b85449be07'
and platform['has_genid'] is False
and {'name':'hypervclock','present':'yes'} in platform['timers'], 'actual selectively observed active KVM platform')
provenance = values['input-provenance.json']
require(provenance['candidate_images'] == ORIGINAL_IMAGES and provenance['operating_assumption'] == ASSUMPTION
and provenance['platform'] == 'kvm_qemu_hypervclock' and provenance['roles_qualified'] is False
and provenance['time_config_created'] is False and provenance['target_called'] is False,
'original incomplete public preparation stays incomplete and unchanged')
return values
def source_inputs():
_, source = read(SOURCE_CASE/'receipt.json',SOURCE_RECEIPT)
read(SOURCE_CASE/'source/crates/agent-windows/src/signed_clock.rs',ORIGINAL_SOURCE_SHA,decode=False)
_, link = read(LINK_CASE/'receipt.json',LINK_RECEIPT)
_, inputs = read(LINK_CASE/'source-inputs.json',LINK_INPUTS)
require(len(inputs) == 202 and len({item['path'] for item in inputs}) == 202,
'exact updated source input set')
clock = [item for item in inputs if item['path'] == 'crates/agent-windows/src/signed_clock.rs']
require(len(clock) == 1 and clock[0]['sha256'] == SOURCE_SHA, 'same qualified V2 clock source')
read(LINK_CASE/'source/crates/agent-windows/src/signed_clock.rs',SOURCE_SHA,decode=False)
original_path = CLOCK/'devstate/windows-signed-clock/trusted-os-candidate-link-542cbf43-afb2-4994-b141-06e003e5e2e8'
_, original = read(original_path/'receipt.json',ORIGINAL_LINK_RECEIPT)
require(source['source_sha256'] == original['source_sha256'] == ORIGINAL_SOURCE_SHA
and source['input_count'] == link['input_count'] == 202
and source['inputs_sha256'] == original['inputs_sha256']
and original['source_receipt_sha256'] == SOURCE_RECEIPT
and link['source_receipt_sha256'] == ORIGINAL_LINK_RECEIPT
and link['source_inputs_sha256'] == LINK_INPUTS
and source['inputs_verified_before_after'] is True and link['source_verified_before_after'] is True
and source['checks']['linux_signed_clock_guards']['passed'] == 8
and link['link_exit'] == 0 and link['original_helper_sha256'] == IMAGES['system_helper']
and link['target'] == 'x86_64-pc-windows-gnu' and link['patches'] == ['656102b','cc82124'],
'actual fixed V2 source and linked product pair, no runtime success inferred')
for artifact, role in ((link['artifacts']['rmm-agent-windows.exe'],'agent'),
(original['artifacts']['rmm-helper-windows.exe'],'system_helper')):
require(artifact['sha256'] == IMAGES[role] and artifact['machine'] == 'PE_AMD64', 'same actual linked role image')
for platform in ('linux','windows'):
case, binary_sha = NATIVE_RESULTS[platform]
_, result = read(LINK_CASE.parent/case/'result.json',link[platform+'_result_sha256'],public=True)
output = result['stdout'] if platform == 'linux' else '\n'.join(result['lines'])
names = re.findall(r'^test (signed_clock::tests::[a-z_]+) \.\.\. ok$', output, re.MULTILINE)
expected = set(source['checks']['linux_signed_clock_guards']['selected']) | {
'signed_clock::tests::passive_sampling_requires_a_profile_and_uses_heartbeat_cadence'}
require(result['test_binary_sha256'] == binary_sha
and result['exit' if platform=='linux' else 'exit_code'] == 0
and len(names) == 9 and set(names) == expected
and '9 passed; 0 failed; 0 ignored' in output, 'same-source actual native nine guards')
return source,link
def raw_inputs():
require(sha(Path(raw_capture.__file__).read_bytes()) ==
'dd6c575a119751429448e40e6f306cf79efa3a86c49bf2cd32a7783937177770',
'unchanged original raw-role decoder')
records = {}
for role, digest in RAW_RECEIPTS.items():
_, receipt = read(RAW/('start-'+role+'-receipt.json'),digest)
raw_link = receipt['raw_reply']
require(raw_link['filename'] == 'start-'+role+'-reply.json', 'fixed original raw role namespace')
_, reply = read(RAW/raw_link['filename'],raw_link['sha256'])
require(receipt['calibrated'] is False and receipt['clock_authority'] is False
and reply['calibrated'] is False and reply['clock_authority'] is False,
'raw probe is never a product calibration')
for key in ('native_witness','server_witness','preservation'):
item = receipt[key]
require(Path(item['filename']).name == item['filename'], 'fixed sibling evidence leaf')
read(RAW/item['filename'],item['sha256'])
raw_capture.validate_role(role,reply['roles'][role],'efd17b43-7e04-49a7-9bd4-862d13365eec')
records[role] = {'receipt_sha256':digest,'probe_image_sha256':raw_capture.EXE_SHA,
'raw_report_sha256':reply['roles'][role]['raw_report_sha256']}
return records
def validate_pair(result, intent):
require(result.get('id') == PAIR_ID and result.get('verified') is True and result.get('completed') is True
and result.get('no_jobs') is True and result.get('windows_jobs_enabled') is False
and result.get('helper_effects_enabled') is False and result.get('clock_adapter_qualified') is False
and result.get('private_key_read') is False, 'actual completed passive pair required; no missing or dummy result')
payload = intent.get('payload',intent)
require(payload['new_agent'] == IMAGES['agent'] and payload['new_helper'] == IMAGES['system_helper']
and payload['qualification_sha256'] == LINK_RECEIPT and payload['manifest_sha256'] == LINK_RECEIPT,
'actual exact V2 pair source chain')
native = result['native']
require(native['binary_sha256'] == IMAGES['agent'] and native['helper_sha256'] == IMAGES['system_helper']
and native['policy_sha256'] == payload['new_policy'] and native['pin_sha256'] == payload['new_pin'], 'complete native image/pin pair')
qualifications = []
for role,service,kernel,label,user in [('agent','service','agent_kernel','agent','S-1-5-19'),('system_helper','helper_service','helper_kernel','helper','S-1-5-18')]:
s,k,f = native[service],native[kernel],native['files'][label]
require(s['state'] == 'Running' and type(s['pid']) is int and s['pid'] > 0
and k['pid'] == s['pid'] and k['creation_filetime'] == s['creation_filetime']
and k['owner_sid'] == s['owner_sid'] == user and k['service_sid_enabled'] is True
and k['kernel_handle_bound'] is True and f['sha256'] == IMAGES[role]
and k['image'] == ('C:\\Program Files\\RustDiscovery\\rmm-agent-windows.exe' if role=='agent'
else 'C:\\Program Files\\RustDiscovery\\rmm-helper-windows.exe')
and re.fullmatch(r'S-1-5-80-(?:[0-9]+-){4}[0-9]+',k['service_sid'])
and re.fullmatch('[0-9]+',k['creation_filetime']) and re.fullmatch('[a-f0-9]{32}',f['file_id']),
'actual SCM/kernel account, enabled service SID, birth and image FileID')
qualifications.append({'role':role,'binary_sha256':IMAGES[role],'service':copy.deepcopy(s),
'kernel':copy.deepcopy(k),'image_file':copy.deepcopy(f)})
return native,payload,qualifications
def produce(public, pair_result, pair_intent, raw, result_sha, intent_sha):
native,payload,roles = validate_pair(pair_result,pair_intent)
binding = public['public-binding.json']; pin=public['qualified-time-public-key.json']
require(native['agent_id'] == binding['agent_id'] and native['asset_id'] == binding['asset_id'], 'same actual device binding')
settings = json.loads(base64.b64decode(payload['settings_base64'],validate=True),object_pairs_hook=strict_object)
require(settings['binding'] == binding and settings['enable_effects'] is False
and settings['agent']['service_sid'] == roles[0]['kernel']['service_sid']
and settings['helper']['service_sid'] == roles[1]['kernel']['service_sid']
and settings['agent']['service_sid'] != settings['helper']['service_sid'], 'actual reciprocal settings and distinct service roles')
platform = {'profile':'rmm.windows.trusted-os.platform-provenance.v1','operating_assumption':ASSUMPTION,
'platform':'kvm_qemu_hypervclock','public_platform_sha256':PUBLIC_SHAS['public-platform.json'],
'original_public_preparation_sha256':PUBLIC_SHAS['input-provenance.json'],
'source_sha256':SOURCE_SHA,'source_receipt_sha256':SOURCE_RECEIPT,
'product_pair_receipt_sha256':LINK_RECEIPT,'pair_result_sha256':result_sha,
'pair_intent_sha256':intent_sha,'independent_physical_calibration_claimed':False}
items={'platform-provenance.json':canonical(platform),'public-platform.json':canonical(public['public-platform.json'])}
# The original platform file is separately retained below using its actual
# bytes; this canonical descriptive copy is never mislabelled as its hash.
references=[]
for role in roles:
role.update(profile='rmm.windows.trusted-os.product-role-prerequisite.v1',pair_case_id=PAIR_ID,
pair_result_sha256=result_sha,pair_intent_sha256=intent_sha,
source_sha256=SOURCE_SHA if role['role']=='agent' else ORIGINAL_SOURCE_SHA,
original_source_receipt_sha256=SOURCE_RECEIPT,product_pair_receipt_sha256=LINK_RECEIPT,
platform_provenance_sha256=sha(items['platform-provenance.json']),
raw_capture=raw['local-service' if role['role']=='agent' else 'system'],
signed_runtime_verified=False,physical_calibration_claimed=False)
name=role['role']+'-qualification.json';items[name]=canonical(role)
references.append({'role':role['role'],'binary_sha256':role['binary_sha256'],'qualification_sha256':sha(items[name])})
value={'schema_version':2,'key_generation':pin['key_generation'],'server_instance':pin['server_instance'],
'binding':binding,'public_keys_hex':{pin['key_id']:pin['public_key_hex']},
'trusted_os_active_guest':{'operating_assumption':ASSUMPTION,'platform':'kvm_qemu_hypervclock',
'platform_provenance_sha256':sha(items['platform-provenance.json']),'qualifications':references}}
items['time-attestation.json']=canonical(value)
require(len(items['time-attestation.json'])<=16384, 'real bounded public V2 configuration')
return items,native,payload
# Controller and transport are defined below; no remote action on import.
HEADER = r'''
$ErrorActionPreference='Stop';$request=$global:RmmTimeProfilePayload
if(!$request-or$request.action-isnot[string]-or$request.action-cnotin@('install','read')-or[guid]::ParseExact($request.id,'D').ToString()-cne$request.id-or$request.profile-cne'rmm.windows.initial-public-time-profile.v2'){throw 'Exact initial time-profile operation'}
$p=$request.pair_payload
$boot='C:\ProgramData\RustDiscoveryBootstrap';$folder=Join-Path $boot ('time-profile-'+$request.id)
$agentRoot='C:\ProgramData\RustDiscovery';$agentState=Join-Path $agentRoot 'state';$helperRoot='C:\ProgramData\RustDiscoverySystem';$helperState=Join-Path $helperRoot 'state'
$config=Join-Path $agentRoot 'config.json';$settings=Join-Path $helperRoot 'helper.json';$pin=Join-Path $helperRoot 'agent-pin.json'
$agentBinary='C:\Program Files\RustDiscovery\rmm-agent-windows.exe';$helperBinary='C:\Program Files\RustDiscovery\rmm-helper-windows.exe'
$agentName='RmmDiscoveryWindows';$helperName='RmmDiscoverySystemHelper';$sys='S-1-5-18';$admin='S-1-5-32-544'
$agentSid=(New-Object Security.Principal.NTAccount('NT SERVICE',$agentName)).Translate([Security.Principal.SecurityIdentifier]).Value
$helperSid=(New-Object Security.Principal.NTAccount('NT SERVICE',$helperName)).Translate([Security.Principal.SecurityIdentifier]).Value
$target=Join-Path $helperRoot 'time-attestation.json';$active=Join-Path $boot 'time-profile-initial-active.json'
'''
BODY = r'''
function ReadAcl($path,[bool]$directory){
Check $path $directory;$acl=Get-Acl -LiteralPath $path
if($acl.GetOwner([Security.Principal.SecurityIdentifier]).Value-cnotin@($sys,$admin)){throw 'Public pin owner must remain SYSTEM/Administrators'}
$seen=@{};foreach($rule in $acl.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier])){
$id=$rule.IdentityReference.Value;$rights=[int64]$rule.FileSystemRights
if($rule.AccessControlType-cne'Allow'-or$id-cnotin@($sys,$admin,$agentSid,$helperSid)-or($id-cnotin@($sys,$admin)-and($rights-band(-bnot 0x1200a9))-ne0)){throw 'Only exact native reader rights, no foreign writer'}
$seen[$id]=$true
};foreach($id in @($sys,$admin)){if(!$seen[$id]){throw 'Privileged public-pin role missing'}}
return $acl
}
function GrantRootReaders{
$acl=ReadAcl $helperRoot $true
foreach($id in @($agentSid,$helperSid)){
$present=$false;foreach($rule in $acl.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier])){if($rule.IdentityReference.Value-ceq$id-and([int64]$rule.FileSystemRights-band0x1200a9)-eq0x1200a9){$present=$true}}
if(!$present){$acl.AddAccessRule((New-Object Security.AccessControl.FileSystemAccessRule((New-Object Security.Principal.SecurityIdentifier($id)),[Security.AccessControl.FileSystemRights]0x1200a9,'None','None','Allow')))}
}
# This-folder-only ACEs: do not expose state/PKI/ledger/intent descendants.
Set-Acl -LiteralPath $helperRoot -AclObject $acl;$null=ReadAcl $helperRoot $true
}
function SetPinAcl($path){
$acl=New-Object Security.AccessControl.FileSecurity;$acl.SetSecurityDescriptorSddlForm(('O:BAG:BAD:P(A;;FA;;;SY)(A;;FA;;;BA)(A;;0x1200a9;;;'+$agentSid+')(A;;0x1200a9;;;'+$helperSid+')'))
Set-Acl -LiteralPath $path -AclObject $acl;$null=ReadAcl $path $false
}
function NewPrivateCase{
[RmmTimeProfileCase]::CreatePrivateOnce($folder);CheckControl $folder $true
}
function FileVolume($path){
$handle=[RmmPipeNative]::CreateFile($path,0x80,7,[IntPtr]::Zero,3,0x2200000,[IntPtr]::Zero)
try{if($handle.IsInvalid){throw 'Protected directory identity handle'};$id=New-Object RmmPipeNative+FileId;if(![RmmPipeNative]::GetFileInformationByHandleEx($handle,18,[ref]$id,24)){throw 'Protected directory volume'};return $id.Volume.ToString([Globalization.CultureInfo]::InvariantCulture)}finally{$handle.Dispose()}
}
function SameLive($before,$after){
Preserved $before $after $false
foreach($field in @('files','service','helper_service','agent_kernel','helper_kernel')){if(!(JsonEqual $before.$field $after.$field)){throw 'Same original data/PKI/FileIDs/services/process generations required'}}
}
function ConfigBytes{
$bytes=[Convert]::FromBase64String($request.config_base64)
if($bytes.Length-gt16384-or$bytes.Length-lt1-or(BytesHash $bytes)-cne$request.config_sha256){throw 'Fixed complete public config bytes'}
$value=[Text.Encoding]::UTF8.GetString($bytes)|ConvertFrom-Json
if($value.schema_version-ne2-or$value.key_generation-ne$request.key_generation-or$value.server_instance-cne$request.server_instance-or!(JsonEqual $value.binding $request.binding)-or$value.trusted_os_active_guest.operating_assumption-cne'active_guest_no_pause_save_restore_snapshot_migration_host_suspend'-or$value.trusted_os_active_guest.platform-cne'kvm_qemu_hypervclock'-or@($value.trusted_os_active_guest.qualifications).Count-ne2-or$value.trusted_os_active_guest.qualifications[0].role-cne'agent'-or$value.trusted_os_active_guest.qualifications[0].binary_sha256-cne$p.new_agent-or$value.trusted_os_active_guest.qualifications[1].role-cne'system_helper'-or$value.trusted_os_active_guest.qualifications[1].binary_sha256-cne$p.new_helper){throw 'Closed real schema2/profile/role binding'}
return ,$bytes
}
CheckControl $boot $true
if($PSCommandPath-cne(Join-Path (Join-Path $boot $request.script_sha256) 'InstallPublicTimeProfile.ps1')-or(Hash $PSCommandPath)-cne$request.script_sha256){throw 'Exact reviewed public-pin controller'}
CheckControl $PSCommandPath $false
$expected=$request.expected_native
$before=ActualState $true;SameLive $expected $before
if($before.agent_kernel.service_sid-cne$agentSid-or$before.helper_kernel.service_sid-cne$helperSid){throw 'Same actual qualified service SIDs'}
$null=ReadAcl $helperRoot $true
if($request.action-ceq'read'){
$records=[ordered]@{};if(Test-Path -LiteralPath $folder){CheckControl $folder $true;foreach($name in @('intent.json','directory-acl-intent.json','directory-acl-done.json','publish-intent.json','result.json')){$path=Join-Path $folder $name;$records[$name]=$null;if(Test-Path -LiteralPath $path){CheckControl $path $false;if((Get-Item -LiteralPath $path -Force).Length-gt2097152){throw 'Bounded original public-pin history'};$records[$name]=Get-Content -LiteralPath $path -Raw|ConvertFrom-Json}}}
if($records['intent.json']){foreach($field in $request.PSObject.Properties.Name){if($field-cne'action'-and!(JsonEqual $records['intent.json'].request.$field $request.$field)){throw 'Same original public-pin intent only'}}}
$activeRecord=$null;if(Test-Path -LiteralPath $active){CheckControl $active $false;if((Get-Item -LiteralPath $active -Force).Length-gt8192){throw 'Bounded public-pin active marker'};$activeRecord=Get-Content -LiteralPath $active -Raw|ConvertFrom-Json;if($activeRecord.id-cne$request.id-or$activeRecord.config_sha256-cne$request.config_sha256-or$activeRecord.script_sha256-cne$request.script_sha256){throw 'Another initial public-pin case; no adoption'}}
$current=$null;if(Test-Path -LiteralPath $target){$null=ReadAcl $target $false;$current=FileIdentity $target;if($current.sha256-cne$request.config_sha256){throw 'Unexpected existing configuration; no adoption'}}
@{id=$request.id;read_only=$true;records=$records;active=$activeRecord;configuration=$current;native=$before;root_sddl=(Get-Acl -LiteralPath $helperRoot).Sddl;clock_runtime_qualified=$false;no_jobs=$true}|ConvertTo-Json -Depth 50 -Compress;exit0
}
if($request.action-cne'install'){throw 'Exact install action only'}
if((Test-Path -LiteralPath $target)-or(Test-Path -LiteralPath $folder)-or(Test-Path -LiteralPath $active)){throw 'Existing initial time profile or partial attempt: original read only'}
$bytes=ConfigBytes
$rootSddl=(Get-Acl -LiteralPath $helperRoot).Sddl
$heldAgent=[RmmPipeNative]::Open([int]$before.service.pid);$heldHelper=[RmmPipeNative]::Open([int]$before.helper_service.pid)
try{
$null=Kernel 'agent' $before.service $heldAgent;$null=Kernel 'helper' $before.helper_service $heldHelper
NewPrivateCase
WriteNew (Join-Path $folder 'intent.json') @{id=$request.id;request=$request;before=$before;original_root_sddl=$rootSddl;no_retry=$true}
WriteNew $active @{id=$request.id;config_sha256=$request.config_sha256;script_sha256=$request.script_sha256;no_retry=$true}
foreach($item in $request.provenance.PSObject.Properties){if($item.Name-cnotmatch'^(platform-provenance|public-platform|original-public-platform|agent-qualification|system_helper-qualification|qualified-time-public-key|public-binding)\.json$'){throw 'Closed public provenance leaves'};$raw=[Convert]::FromBase64String($item.Value);if($raw.Length-gt65536){throw 'Bounded public provenance'};WriteBytes (Join-Path $folder $item.Name) $raw}
$staged=Join-Path $folder 'time-attestation.candidate.json';WriteBytes $staged $bytes;SetPinAcl $staged
if((FileIdentity $staged).sha256-cne$request.config_sha256-or(FileVolume $folder)-cne(FileVolume $helperRoot)){throw 'Verified complete same-volume public pin'}
SameLive $before (ActualState $true)
if((Get-Acl -LiteralPath $helperRoot).Sddl-cne$rootSddl){throw 'Immediate directory ACL CAS'}
WriteNew (Join-Path $folder 'directory-acl-intent.json') @{old_sddl=$rootSddl;readers=@($agentSid,$helperSid);this_folder_only=$true}
GrantRootReaders
WriteNew (Join-Path $folder 'directory-acl-done.json') @{sddl=(Get-Acl -LiteralPath $helperRoot).Sddl}
SameLive $before (ActualState $true)
$null=Kernel 'agent' $before.service $heldAgent;$null=Kernel 'helper' $before.helper_service $heldHelper
if(Test-Path -LiteralPath $target){throw 'Target appeared before no-overwrite publication'}
$stagedId=FileIdentity $staged
WriteNew (Join-Path $folder 'publish-intent.json') @{config_sha256=$request.config_sha256;staged=$stagedId;create_once=$true}
[IO.File]::Move($staged,$target)
$null=ReadAcl $target $false;$published=FileIdentity $target
if(!(JsonEqual $published $stagedId)){throw 'Exact same file identity/hash/ACL after publication'}
$after=ActualState $true;SameLive $before $after
$null=Kernel 'agent' $before.service $heldAgent;$null=Kernel 'helper' $before.helper_service $heldHelper
$result=@{id=$request.id;installed=$true;configuration=$published;native=$after;original_root_sddl=$rootSddl;root_sddl=(Get-Acl -LiteralPath $helperRoot).Sddl;no_jobs=$true;clock_runtime_qualified=$false;services_changed=$false;private_key_read=$false}
WriteNew (Join-Path $folder 'result.json') $result;$result|ConvertTo-Json -Depth 50 -Compress
}finally{$heldAgent.Dispose();$heldHelper.Dispose()}
'''.replace('exit0','exit 0')
def controller():
"""Reuse only existing read-only witnesses, not any old phase/repair code."""
require(sha(Path(prior.__file__).read_bytes()) == 'e466576673a0e5c332cfc1613ae88a62f5b526015ced76b1d22473e292a995e0'
and sha(Path(prior.u.__file__).read_bytes()) == 'f8dc1c8fbc064e253b1fbe130fb628afef58cf45c2bafb6837d6716125b42d38', 'unchanged reviewed original readonly witness sources')
source = prior.u.SCRIPT
# Every selected section ends at the next named function. No StartOnce,
# StopPinned, Swap, Backup, original phase, or old payload dispatch is copied.
names = ['Check','BytesHash','Hash','AclHash','CheckControl','Service','Probe','Diagnostic','RawAgentProbe','EmptyIntentStore','State','Preserved']
functions=[]
for name in names:
start=source.index('function '+name+'(') if 'function '+name+'(' in source else source.index('function '+name+'{')
end=source.find('\nfunction ',start+1)
require(end>start, 'closed existing readonly witness boundary')
functions.append(source[start:end])
# File writers are new, closed by the controller's fixed namespace only.
writers=r'''function WriteBytes($path,[byte[]]$bytes){$file=[IO.File]::Open($path,[IO.FileMode]::CreateNew,[IO.FileAccess]::Write,[IO.FileShare]::Read);try{$file.Write($bytes,0,$bytes.Length);$file.Flush($true)}finally{$file.Dispose()}}
function WriteNew($path,$value){WriteBytes $path ([Text.Encoding]::UTF8.GetBytes(($value|ConvertTo-Json -Depth 50 -Compress)))}'''
return HEADER+'\n'+STRUCTURAL+'\n'+'\n'.join(functions)+'\n'+prior.NATIVE+'\n'+CASE_NATIVE+'\n'+writers+'\n'+BODY
# Same reviewed structural comparison as e6debe5; member order is not identity.
STRUCTURAL = r'''function CanonicalStateValue($value,[int]$depth=0){
if($depth-gt40){throw 'Bounded state comparison depth'}
if($null-eq$value){return $null}
if($value-is[Collections.IDictionary]){$result=[ordered]@{};foreach($key in @($value.Keys|Sort-Object -CaseSensitive)){if($key-isnot[string]-or$result.Contains($key)){throw 'Nonunique state object key'};$result[$key]=CanonicalStateValue $value[$key] ($depth+1)};return $result}
if($value-is[pscustomobject]){$result=[ordered]@{};foreach($property in @($value.PSObject.Properties|Sort-Object -Property Name -CaseSensitive)){if($property.Name-isnot[string]-or$result.Contains($property.Name)){throw 'Nonunique state object key'};$result[$property.Name]=CanonicalStateValue $property.Value ($depth+1)};return $result}
if($value-is[Collections.IEnumerable]-and$value-isnot[string]){$result=New-Object 'Collections.Generic.List[object]';foreach($item in $value){$result.Add((CanonicalStateValue $item ($depth+1)))};return ,$result.ToArray()}
return $value
}
function JsonEqual($a,$b){return((ConvertTo-Json -InputObject (CanonicalStateValue $a) -Depth 40 -Compress)-ceq(ConvertTo-Json -InputObject (CanonicalStateValue $b) -Depth 40 -Compress))}'''
CASE_NATIVE = r'''Add-Type -TypeDefinition @'
using System;
using System.ComponentModel;
using System.Runtime.InteropServices;
using System.Security.AccessControl;
public static class RmmTimeProfileCase {
[StructLayout(LayoutKind.Sequential)] struct Attributes {public int Length;public IntPtr Descriptor;public int Inherit;}
[DllImport("kernel32.dll",EntryPoint="CreateDirectoryW",ExactSpelling=true,CharSet=CharSet.Unicode,SetLastError=true)]
[return:MarshalAs(UnmanagedType.Bool)] static extern bool CreateDirectory(string path,ref Attributes security);
public static void CreatePrivateOnce(string path){
RawSecurityDescriptor sd=new RawSecurityDescriptor("O:BAG:BAD:P(A;OICI;FA;;;SY)(A;OICI;FA;;;BA)");
byte[] raw=new byte[sd.BinaryLength];sd.GetBinaryForm(raw,0);GCHandle pin=GCHandle.Alloc(raw,GCHandleType.Pinned);
try{Attributes attributes=new Attributes{Length=Marshal.SizeOf(typeof(Attributes)),Descriptor=pin.AddrOfPinnedObject(),Inherit=0};
if(!CreateDirectory(path,ref attributes))throw new Win32Exception(Marshal.GetLastWin32Error(),"TIME_PROFILE_PRIVATE_CREATE_ONCE");
}finally{pin.Free();}
}
}
'@'''
LAUNCH = r'''$ErrorActionPreference='Stop';$request=([Console]::In.ReadLine()|ConvertFrom-Json)
if(!$request-or$request.action-isnot[string]-or$request.action-cnotin@('install','read')-or$request.script_sha256-cnotmatch'^[a-f0-9]{64}$'){throw 'Fixed public-pin launch'}
$script=Join-Path (Join-Path 'C:\ProgramData\RustDiscoveryBootstrap' $request.script_sha256) 'InstallPublicTimeProfile.ps1'
$item=Get-Item -LiteralPath $script -Force;if($item.PSIsContainer-or($item.Attributes-band[IO.FileAttributes]::ReparsePoint)-or$item.Length-gt100000-or(Get-FileHash -LiteralPath $script -Algorithm SHA256).Hash.ToLowerInvariant()-cne$request.script_sha256){throw 'Exact bounded immutable time-pin script'}
$acl=Get-Acl -LiteralPath $script;if($acl.GetOwner([Security.Principal.SecurityIdentifier]).Value-cnotin@('S-1-5-18','S-1-5-32-544')){throw 'Private launch owner'}
foreach($rule in $acl.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier])){if($rule.AccessControlType-cne'Allow'-or$rule.IdentityReference.Value-cnotin@('S-1-5-18','S-1-5-32-544')){throw 'Private launch DACL'}}
$global:RmmTimeProfilePayload=$request;& $script
'''
def guards():
script=controller()
for forbidden in ('Stop-Service','Start-Service','Restart-Computer','Set-Date','AdjustTokenPrivileges',
'function Swap','function Backup','function StartOnce','CreateService(', 'DeleteService('):
require(forbidden not in script, 'no service/clock/job effect imported')
require("$request.action-cnotin@('install','read')" in script
and "if($request.action-cne'install')" in script
and '[IO.File]::Move($staged,$target)' in script
and script.index("'publish-intent.json') @") < script.index('[IO.File]::Move($staged,$target)')
and 'This-folder-only ACEs' in script and '0x1200a9' in script
and 'CreatePrivateOnce' in script, 'closed create-once public-pin effects')
return script
def prepare():
# All prerequisites are checked BEFORE creating a local installation case.
# Source/link/role constants deliberately remain unset until actual evidence.
require(PAIR_ID is not None and str(uuid.UUID(PAIR_ID)) == PAIR_ID
and all(isinstance(value,str) and re.fullmatch('[a-f0-9]{64}',value)
for value in (PAIR_RESULT_SHA,PAIR_INTENT_SHA)),
'actual completed new pair and independently pinned role readback required')
public=public_inputs(); source_inputs(); raw=raw_inputs()
pair=PAIR_ROOT/PAIR_ID
result_raw,result=read(pair/'result.json',PAIR_RESULT_SHA)
intent_path=pair/'intent.json'
if not intent_path.exists(): intent_path=pair/'bound-payload.json'
intent_raw,intent=read(intent_path,PAIR_INTENT_SHA)
items,native,payload=produce(public,result,intent,raw,sha(result_raw),sha(intent_raw))
items['original-public-platform.json']=read(PUBLIC/'public-platform.json',PUBLIC_SHAS['public-platform.json'])[0]
for name in ('qualified-time-public-key.json','public-binding.json'):
items[name]=read(PUBLIC/name,PUBLIC_SHAS[name])[0]
script=guards().encode(); ident=str(uuid.uuid4()); script_sha=sha(script)
keep=('old_agent','old_helper','new_agent','new_helper','old_policy','old_pin','new_policy','new_pin',
'config_sha256','probe_sha256','system_probe_sha256','intent_leaves')
public_payload={key:payload[key] for key in keep}
request={'profile':'rmm.windows.initial-public-time-profile.v2','id':ident,'action':'read',
'script_sha256':script_sha,'config_sha256':sha(items['time-attestation.json']),
'config_base64':base64.b64encode(items.pop('time-attestation.json')).decode(),
'pair_payload':public_payload,'expected_native':native,'binding':public['public-binding.json'],
'key_generation':public['qualified-time-public-key.json']['key_generation'],
'server_instance':public['qualified-time-public-key.json']['server_instance'],
'provenance':{name:base64.b64encode(value).decode() for name,value in items.items()}}
# Existing transport passes the payload on stdin, not on the command line.
require(len(canonical(request))<=128*1024,'bounded public bootstrap request')
STATE.mkdir(mode=0o700,parents=True,exist_ok=True);ident_dir=STATE/ident;ident_dir.mkdir(mode=0o700)
write(ident_dir/'InstallPublicTimeProfile.ps1',script)
write(ident_dir/'time-attestation.json',base64.b64decode(request['config_base64'],validate=True))
for name,value in items.items(): write(ident_dir/name,value)
manifest={'profile':request['profile'],'id':ident,'generator_sha256':sha(Path(__file__).read_bytes()),
'script_sha256':script_sha,'request':request,'pair_result_sha256':sha(result_raw),
'pair_intent_sha256':sha(intent_raw),'source_receipt_sha256':SOURCE_RECEIPT,
'product_link_receipt_sha256':LINK_RECEIPT,'target_called':False,'clock_runtime_qualified':False,
'files':{name:{'sha256':sha(value),'bytes':len(value)} for name,value in items.items()}}
write(ident_dir/'manifest.json',canonical(manifest))
print(json.dumps({'id':ident,'prepared_locally':True,'target_called':False,
'config_sha256':request['config_sha256'],'manifest_sha256':sha(canonical(manifest))}))
def load_case(ident):
require(str(uuid.UUID(ident))==ident and uuid.UUID(ident).version==4,'canonical original time-pin case')
folder=STATE/ident; _,manifest=read(folder/'manifest.json')
require(manifest['id']==ident and manifest['generator_sha256']==sha(Path(__file__).read_bytes())
and manifest['script_sha256']==sha(guards().encode()),'same exact reviewed operator and case')
require(read(folder/'InstallPublicTimeProfile.ps1',decode=False)[0]==guards().encode(), 'same controller bytes')
request=manifest['request'];read(folder/'time-attestation.json',request['config_sha256'])
for name,item in manifest['files'].items(): read(folder/name,item['sha256'])
return folder,manifest
def target(action,ident):
"""Only Root invokes these explicit phases after independent review."""
folder,manifest=load_case(ident)
require(action in ('stage','install','read'),'closed public-pin phase')
if action!='read':
write(folder/(action+'-attempt.json'),canonical({'id':ident,'action':action,'once':True,'lost_reply_read_original_case_only':True}))
access=raw_capture.CaptureAccess(MAIN)
if action=='stage':
path=folder/'InstallPublicTimeProfile.ps1';digest=manifest['script_sha256']
stage=prior.u.transport.PREPARE_SCRIPT.replace('TransportAcceptance.ps1',path.name)
observed=access.powershell(stage,{'sha256':digest})
if not observed['already_uploaded']:
import subprocess
config=prior.cb.contract.protected_json(MAIN/'credentials/windows-dev-access.json')
prefix=config['ssh_prefix'];args=['sftp']+[p for p in prefix[1:-1] if p!='-T']+['-b','-',prefix[-1]]
remote='/C:/ProgramData/RustDiscoveryBootstrap/'+digest+'/'+path.name
reply=subprocess.run(args,input=('put '+json.dumps(str(path.resolve()))+' '+json.dumps(remote)+'\n').encode(),capture_output=True,timeout=60)
write(folder/'stage-transport.json',canonical({'returncode':reply.returncode,'stdout_b64':base64.b64encode(reply.stdout).decode(),'stderr_b64':base64.b64encode(reply.stderr).decode()}))
require(reply.returncode==0,'once-only fixed script transfer; lost reply read only')
observed=access.powershell(stage,{'sha256':digest})
require(observed['already_uploaded'] is True and observed['sha256']==digest,'exact staged public-pin controller')
result={'id':ident,'staged':True,'script_sha256':digest,'configuration_installed':False}
else:
request=copy.deepcopy(manifest['request']);request['action']=action
result=access.powershell(LAUNCH,request,timeout=120)
require(result['id']==ident and result.get('no_jobs') is True and result.get('clock_runtime_qualified') is False,
'same native public-pin result, never clock readiness')
output=folder/((action+'-'+str(uuid.uuid4()) if action=='read' else action)+'-reply.json')
write(output,canonical(result))
print(json.dumps({'id':ident,'action':action,'reply_sha256':sha(canonical(result)),'clock_runtime_qualified':False}))
if __name__=='__main__':
parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('action',choices=('guards','prepare','stage','install','read'));parser.add_argument('--case');arguments=parser.parse_args()
if arguments.action=='guards': guards();print('PASS closed public-profile source guards; no target action')
elif arguments.action=='prepare': prepare()
else: target(arguments.action,arguments.case)
+120
View File
@@ -0,0 +1,120 @@
# Erste öffentliche Windows-Zeitkonfiguration V2
Stand 2026-11-15: `deploy/windows/time_profile_config.py` bereitet den eng
begrenzten Bootstrap einer ersten `time-attestation.json` vor. Die tatsächliche
Paarwartung und neue Rollenbelege fehlen noch. Deshalb sind `PAIR_ID`,
`PAIR_RESULT_SHA` und `PAIR_INTENT_SHA` absichtlich nicht gesetzt. `prepare`
verweigert **vor** dem Anlegen eines lokalen Falls. Es wurde keine Konfiguration
auf der VM angelegt, kein Dienst geändert und kein Job erzeugt.
Der Operator prüft die unveränderten öffentlichen Vorbereitungsbelege
`c3077acf-12da-410e-9f55-e75a1cd0a75f`, deren getrennten Ed25519-Zeitschlüssel,
Gerätebindung und tatsächlich gelesene KVM-Plattform. Die ursprüngliche
Vorbereitung bleibt mit `roles_qualified=false` unverändert. Die akzeptierte
Betriebsannahme ist ausdrücklich
`active_guest_no_pause_save_restore_snapshot_migration_host_suspend`; das ist
keine physikalische Kalibrierung und keine automatische Überwachung dieser
Betriebsannahme.
Der neue Agent ist an SHA256
`0549d9ebea73cff996938f859b92192cc333de194128d7c6859a3f1d2e85893c`
und Buildreceipt `f04024f78c2f11f5c66bbdf9278467f5bcc50da5c2bd7336623851bca42dd446`
gebunden. Seine 202 Quellinputs sind durch `11717fab…` fixiert; das tatsächlich
erweiterte Zeitmodul hat SHA256 `342494c4…`. Gegen die ursprüngliche Quelle
`d8594c1e…` kamen die passive Sampling-Auswahl und deren neunte Prüfung hinzu.
Der Helper bleibt `59675a3c…`, aus dem ursprünglichen Linkbeleg `04ed34e6…`
und Quellbeleg `96b05fe1…`. Diese unterschiedlichen Provenienzen werden nicht
gleichgesetzt. Der tatsächliche neue Paar-Payload verwendet für
`qualification_sha256` und `manifest_sha256` jeweils den neuen Beleg `f04024f7…`;
der alte Helper-Quellbeleg ist kein Ersatz dafür.
Bevor ein Fall erstellt werden kann, müssen ein abgeschlossener passiver
Paarwechsel und unabhängig fixierte Originalbelege vorliegen. Für beide Rollen
werden SCM-Status, PID, Kernel-Prozessgeburt, tatsächliches Konto, aktivierte
Service-SID, gehaltener Prozesshandle, Imagepfad, Imagehash und native FileID
verknüpft. Die alten numerischen 601-Proben bleiben ausdrücklich rohe
Voraussetzungsbelege; sie qualifizieren kein Produktimage. Der Producer erzeugt
öffentliche Rollen- und Plattformbelege und daraus das vorhandene strikte
V2-Format mit genau beiden Rollen. Er behauptet weder signierte Laufzeitprüfung
noch physikalische Genauigkeit. Fehlende oder widersprüchliche Belege sperren.
## Geplanter Ablauf nach neuem realem Paar-Readback
Die folgenden Phasen sind **vorbereitet, nicht auf dem Ziel ausgeführt**:
1. Root bestätigt Original-Paarfall und Originalbeleg-Hashes; diese werden als
konkrete Quellenkonstanten gebunden und nochmals geprüft.
2. `prepare` liest ausschließlich öffentliche lokale Belege und erzeugt einen
privaten, einmaligen Fall. `stage --case <id>` überträgt ausschließlich den
fixierten Controller über den bestehenden bestätigten SSH-Transport.
3. `install --case <id>` darf genau eine bisher fehlende feste öffentliche Datei
veröffentlichen. Bereits vorhandene Datei, aktiver Marker oder Teilfall
verweigern einen neuen Installationsversuch. Ein verlorener Antwortweg führt
ausschließlich zu `read --case <id>`, nicht zu Wiederholung oder Rollback.
4. Root liest den ursprünglichen Fall separat und prüft danach die echten
passiven Agent-/Helper-Zeitbelege. Eine erfolgreiche Veröffentlichung allein
setzt `clock_runtime_qualified` ausdrücklich nicht auf true.
## Begrenzte Wirkung und Erhaltungsnachweis
Der Controller verwendet ausschließlich die vorhandenen lesenden SCM-,
Kernel-, FileID-, PKI-Metadaten- und Journalzeugen. Er importiert keine alten
Stop-/Start-/Swap-/Repair-Phasen. Die aktuelle Prozessgeneration, beide Images,
vier Code-/Policydateien, Konfiguration, Geräteidentität, Zertifikat,
Schlüsselmetadaten, Telemetrieidentität, Sequenzmonotonie und leere
Job-/Helper-Intents werden vor, während und nach der Veröffentlichung geprüft.
Der private Schlüssel wird weder gelesen noch gehasht.
Eine neue private Bootstrap-Falldirectory wird nativ exklusiv mit geschützter
SYSTEM-/Administrators-DACL angelegt. Alle Originalmarker werden create-only
geschrieben und geflusht. Nur der öffentliche Helper-Stamm erhält bei Bedarf
fehlende `0x001200a9`-Leserechte für beide **Service-SIDs**, ausschließlich für
diesen Ordner, ohne Vererbung auf State/PKI/Ledger. Fremde oder weiter gehende
Service-Rechte werden verweigert. Die Kandidatdatei erhält vor Veröffentlichung
SYSTEM/Administrators-Vollzugriff und dieselben begrenzten Leser. Die feste
Zieldatei wird nach durablem Publish-Intent mit einem gleichvolumigen,
überschreibungsfreien Move veröffentlicht; anschließend müssen FileID, Hash
und DACL unverändert sein. Keine allgemeine Stromausfall-Atomizität wird daraus
abgeleitet. Teilzustände bleiben im Originalfall lesbar, ohne automatische
Reparatur oder Rechte-Rücksetzung.
## Laden und tatsächliche Grenzen
Das vorhandene `signed_clock::native::SignedClock::open` lädt bei jedem Öffnen
geschützte Settings, beweist den eigenen Dienstprozess und öffnet den festen
Stamm sowie die maximal 16384 Byte große Datei über `PinnedFile`. Besitzer
müssen SYSTEM/Administrators bleiben; zusätzliche Leser dürfen nur die
festgelegte Lesemaske besitzen. Beide Images müssen zu den Settings passen.
Die Prüfung bindet Dateiinhalt und FileID; spätere Rechecks öffnen denselben
Namen erneut und verwerfen Austausch oder Änderungen. Fehlerhaft beobachtete
Konfigurationen oder fehlgeschlagene Reads stellen alte Autorität nicht wieder
her; geänderte Bytes derselben Generation gelten als Fork.
Im neuen Agenten versucht die passive Heartbeat-Schleife das Setup bei bisher
fehlendem Profil erneut. Ein erster Pin benötigt daher nach Quellenvertrag
keinen Dienstneustart. Das ist **noch kein VM-Nachweis**. Der Agent schreibt erst
nach tatsächlich erfolgreichem `complete` pro Verbindung öffentliche historische
`agent-time-sample.json` und `helper-time-sample.json` in sein bestehendes
geschütztes State-Verzeichnis. Der Helper-State bleibt unverändert. Root muss
diese Originalbelege noch für die tatsächlich installierten Rollen und
Konfigurationsbytes prüfen. Ein Statusfile ersetzt kein aktuelles Job-Startgate.
## Tatsächlich lokal ausgeführt
- Python-Syntaxprüfung und geschlossene Sourceguards: PASS.
- Sechs lokale Vertragsfälle: PASS. Sie prüfen die reinen Referenzbytes,
fehlende Paarbelege, falsche Rollen/Images/Geburt/SID/FileID/Policy/Identität,
create-only, begrenztes Lesen, Symlink- und Duplicate-JSON-Verweigerung.
Positive In-Memory-Fixtures sind ausdrücklich keine native Qualifikation.
- Beide erzeugten PowerShell-ASTs mit vorhandenem lokalem Parser: PASS.
- Die festgehaltenen öffentlichen Eingänge, rohen Rollenbelege und realen
Quell-/Buildbelege werden vom Operator lokal erfolgreich gelesen. Die durch
Root tatsächlich ausgeführten neun Linux- und neun Windows-Zeitmodulprüfungen
sind über deren Originalbeleg-Hashes und exakte Testnamen angebunden.
- `prepare` ohne reale Paarbelege: erwartete Verweigerung ohne angelegten Fall.
Nicht ausgeführt: Übertragung, ACL-Änderung, Konfigurationsinstallation,
Produktdienst-Laden/Reopen auf der VM, signierte passive Laufzeitabnahme,
WebUI-Genehmigung oder RMM-Job. Nach Notebook-Suspend fehlt aktuell der
antwortende SSH-Transport; der vorbereitete Paarfall `570c7a86…` hat keine
neuen Rollenbelege und darf nicht als abgeschlossener Wechsel verwendet werden.