Compare commits

..
Author SHA1 Message Date
kevin_janssen 0ecfb98204 Accept passive agent update observations with verified SQLx migration
Rust development slice / linux (push) Failing after 7s
2026-11-15 16:44:24 +01:00
kevin_janssen 03e5964474 Merge commit '7c643b0'
Rust development slice / linux (push) Failing after 6s
2026-11-15 16:16:18 +01:00
kevin_janssen 5d3141f1df Merge commit '4ba2439' 2026-11-15 16:16:18 +01:00
kevin_janssen 4ba243998c Verify typed Windows maintenance controller and fresh original pair baseline
Rust development slice / linux (push) Failing after 7s
2026-11-15 16:16:03 +01:00
kevin_janssen d3cd373d5e Merge commit '0c970dc'
Rust development slice / linux (push) Failing after 6s
2026-11-15 16:14:23 +01:00
kevin_janssen b47677b3a5 Merge commit '99aedc1' 2026-11-15 16:14:23 +01:00
kevin_janssen 0c970dc6c0 Preserve native profile install bound and PS5 scalar identity
Rust development slice / linux (push) Failing after 7s
2026-11-15 16:14:10 +01:00
kevin_janssen 99aedc14b1 Normalize ETS-wrapped JSON scalars before Windows maintenance state comparison
Rust development slice / linux (push) Failing after 7s
2026-11-15 16:14:01 +01:00
kevin_janssen 4c6874a92b Merge commit 'f6ebd0230877d2805ab7cd117d095f187e8305c7'
Rust development slice / linux (push) Failing after 7s
2026-11-15 16:11:47 +01:00
kevin_janssen b5425fc152 Merge commit 'cdcdb36'
Rust development slice / linux (push) Failing after 6s
2026-11-15 16:09:42 +01:00
kevin_janssen 8d1e6c99d7 Merge commit '2f9e453' 2026-11-15 16:09:42 +01:00
kevin_janssen 2f9e45302a Verify final Windows passive pair staging and fresh native baseline after reconnect
Rust development slice / linux (push) Failing after 7s
2026-11-15 16:06:37 +01:00
kevin_janssen 3ec30d373d Verify resumed Windows maintenance window on the guest
Rust development slice / linux (push) Failing after 7s
2026-11-15 16:04:57 +01:00
kevin_janssen 43e696ff3f Resume the interrupted foreground console window within its existing deadline
Rust development slice / linux (push) Failing after 7s
2026-11-15 16:02:07 +01:00
kevin_janssen 16eb5f86cf Identify individual Windows maintenance preflight mismatches
Rust development slice / linux (push) Failing after 7s
2026-11-15 15:59:26 +01:00
kevin_janssen 4e55e04b97 Merge commit '8bee0ad'
Rust development slice / linux (push) Failing after 6s
2026-11-15 15:54:07 +01:00
kevin_janssen 8bee0ad5e6 Prepare fail-closed first Windows V2 public time profile operator
Rust development slice / linux (push) Failing after 7s
2026-11-15 15:53:51 +01:00
kevin_janssen 7f4066b337 Verify stored Windows telemetry reached MCP after notebook resume
Rust development slice / linux (push) Failing after 6s
2026-11-15 15:53:07 +01:00
kevin_janssen 725cddd5b2 Merge commit '44f65c205b1db0849654bb4e38ff766d491e90b2'
Rust development slice / linux (push) Failing after 6s
2026-11-15 15:52:04 +01:00
kevin_janssen ef509b3eb2 Merge commit 'd9c1311'
Rust development slice / linux (push) Failing after 7s
# Conflicts:
#	docs/windows-signed-clock-upgrade-plan.md
2026-11-15 15:49:58 +01:00
kevin_janssen 0ef1959c07 Link the exact Windows release sources and current VM acceptance state
Rust development slice / linux (push) Failing after 6s
2026-11-15 15:49:35 +01:00
kevin_janssen d9c1311332 Bind final passive Windows agent and record transport refusal without service effects
Rust development slice / linux (push) Failing after 6s
2026-11-15 15:49:25 +01:00
kevin_janssen 64214fc41a Record Windows agent recovery and SSH banner timeout after host suspend
Rust development slice / linux (push) Failing after 7s
2026-11-15 15:48:27 +01:00
kevin_janssen 95bcd201fc Qualify the exact passive release source on the Windows VM
Rust development slice / linux (push) Failing after 6s
2026-11-15 14:47:50 +01:00
11 changed files with 1118 additions and 33 deletions
@@ -3,7 +3,8 @@
[CmdletBinding()]
param(
[Parameter(Mandatory)][DateTimeOffset]$PreviousExpiry,
[Parameter(Mandatory)][DateTimeOffset]$Until
[Parameter(Mandatory)][DateTimeOffset]$Until,
[switch]$ResumeInterrupted
)
$ErrorActionPreference = 'Stop'
$utcNow = [DateTimeOffset]::UtcNow
@@ -16,11 +17,25 @@ $raw = [IO.File]::ReadAllText($configPath)
$cfg = $raw | ConvertFrom-Json
$user = Get-LocalUser -Name 'rmm-dev'
$task = Get-ScheduledTask -TaskPath '\' -TaskName 'RmmDevReverseTunnel'
if ($task.State -ne 'Ready' -or !$user.Enabled -or !$user.AccountExpires -or
$user.AccountExpires.ToUniversalTime() -ne $PreviousExpiry.UtcDateTime -or
[DateTimeOffset]::Parse($cfg.expires_at) -ne $PreviousExpiry -or
$cfg.server -cne 'discovery.ease-technologies.de' -or (Get-Service sshd).Status -ne 'Running') {
throw 'Unexpected account, task, server or previous expiry.'
$expectedState = if ($ResumeInterrupted) { 'Disabled' } else { 'Ready' }
$expectedExpiry = if ($ResumeInterrupted) { $Until } else { $PreviousExpiry }
$mismatches = @(
if ($task.State -ne $expectedState) { "task state $($task.State) (expected $expectedState)" }
if (!$user.Enabled) { 'rmm-dev is disabled' }
if (!$user.AccountExpires) {
'rmm-dev has no account expiry'
} elseif ($user.AccountExpires.ToUniversalTime() -ne $expectedExpiry.UtcDateTime) {
"account expiry $($user.AccountExpires.ToUniversalTime().ToString('o')) (expected $($expectedExpiry.UtcDateTime.ToString('o')))"
}
if ([DateTimeOffset]::Parse($cfg.expires_at) -ne $expectedExpiry) {
"configuration expiry $($cfg.expires_at) (expected $($expectedExpiry.UtcDateTime.ToString('o')))"
}
if ($cfg.server -cne 'discovery.ease-technologies.de') { 'configured server differs' }
$sshdState = (Get-Service -Name sshd).Status
if ($sshdState -ne 'Running') { "sshd state $sshdState (expected Running)" }
)
if ($mismatches.Count -gt 0) {
throw ('Maintenance window preflight failed: ' + ($mismatches -join ', '))
}
$pinned = (Get-Content -LiteralPath (Join-Path $dir 'known_hosts') -Raw).Trim()
if ($pinned -cne ('discovery.ease-technologies.de ' + $cfg.server_host_key)) {
@@ -31,9 +46,27 @@ if ($listeners.Count -ne 1 -or $listeners[0].LocalAddress -ne '127.0.0.1') {
throw 'Expected only the original loopback SSH listener.'
}
$backup = Join-Path $dir ('console-window-' + [guid]::NewGuid().ToString() + '.bak')
$originalRaw = $raw
if ($ResumeInterrupted) {
$owners = @(Get-CimInstance Win32_Process -Filter "Name='powershell.exe' OR Name='pwsh.exe' OR Name='ssh.exe'" | Where-Object {
$_.ProcessId -ne $PID -and ($_.CommandLine -match '(?:rmm-window-[0-9a-f-]+|Open-ConsoleMaintenanceWindow)\.ps1' -or
($_.Name -eq 'ssh.exe' -and $_.CommandLine -match '127\.0\.0\.1:22240:127\.0\.0\.1:22222'))
})
if ($owners.Count) { throw 'An existing maintenance console or forwarding process is still active. End the original console with Ctrl+C first.' }
$copies = @(Get-ChildItem -LiteralPath $dir -Filter 'console-window-*.bak' -File -Force)
if ($copies.Count -ne 1 -or $copies[0].Name -notmatch '^console-window-[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}\.bak$' -or
($copies[0].Attributes -band [IO.FileAttributes]::ReparsePoint) -or $copies[0].Length -gt 32768) {
throw 'Expected one original maintenance-window backup.'
}
$backup = $copies[0].FullName
if (Test-Path -LiteralPath ($backup + '.closed')) { throw 'Backup already closed.' }
$originalRaw = [IO.File]::ReadAllText($backup)
$original = $originalRaw | ConvertFrom-Json
if ([DateTimeOffset]::Parse($original.expires_at) -ne $PreviousExpiry) { throw 'Backup expiry differs.' }
$original.expires_at = $Until.ToUniversalTime().ToString('yyyy-MM-ddTHH:mm:sszzz')
if (($original | ConvertTo-Json -Compress) -cne $raw) { throw 'Backup does not reconstruct the current public configuration.' }
}
$candidate = $backup + '.new'
$cfg.expires_at = $Until.ToUniversalTime().ToString('yyyy-MM-ddTHH:mm:sszzz')
[IO.File]::WriteAllText($candidate, ($cfg | ConvertTo-Json -Compress), (New-Object Text.UTF8Encoding($false)))
$sshArgs = @('-F','NUL','-N','-T','-o','BatchMode=yes','-o','IdentitiesOnly=yes',
'-o','ForwardAgent=no','-o','StrictHostKeyChecking=yes','-o','GlobalKnownHostsFile=NUL',
'-o',('UserKnownHostsFile=' + $dir + '\known_hosts'),'-o','ExitOnForwardFailure=yes',
@@ -44,12 +77,20 @@ $ssh = $null
$disabled = $false
$accountChanged = $false
try {
Disable-ScheduledTask -InputObject $task | Out-Null
$disabled = $true
if (!$ResumeInterrupted) {
$cfg.expires_at = $Until.ToUniversalTime().ToString('yyyy-MM-ddTHH:mm:sszzz')
[IO.File]::WriteAllText($candidate, ($cfg | ConvertTo-Json -Compress), (New-Object Text.UTF8Encoding($false)))
Disable-ScheduledTask -InputObject $task | Out-Null
$disabled = $true
}
if ((Get-ScheduledTask -TaskPath '\' -TaskName $task.TaskName).State -ne 'Disabled' -or
[IO.File]::ReadAllText($configPath) -cne $raw) { throw 'Existing bootstrap changed.' }
[IO.File]::Replace($candidate, $configPath, $backup)
Set-LocalUser -SID $user.SID -AccountExpires $Until.LocalDateTime
if ($ResumeInterrupted) {
$disabled = $true
} else {
[IO.File]::Replace($candidate, $configPath, $backup)
Set-LocalUser -SID $user.SID -AccountExpires $Until.LocalDateTime
}
$accountChanged = $true
if ((Get-LocalUser -SID $user.SID).AccountExpires.ToUniversalTime() -ne $Until.UtcDateTime) {
throw 'Unexpected account expiry after renewal.'
@@ -65,7 +106,7 @@ try {
try { if (!$ssh.HasExited) { $ssh.Kill(); $ssh.WaitForExit() } } finally { $ssh.Dispose() }
}
if ($accountChanged) { Set-LocalUser -SID $user.SID -AccountExpires $PreviousExpiry.LocalDateTime }
if (Test-Path -LiteralPath $backup) { [IO.File]::Replace($backup, $configPath, ($backup + '.closed')) }
if ($disabled -and [IO.File]::ReadAllText($configPath) -ceq $raw) { Enable-ScheduledTask -InputObject $task | Out-Null }
if (Test-Path -LiteralPath $candidate) { Remove-Item -LiteralPath $candidate }
if ($disabled -and (Test-Path -LiteralPath $backup)) { [IO.File]::Replace($backup, $configPath, ($backup + '.closed')) }
if ($disabled -and [IO.File]::ReadAllText($configPath) -ceq $originalRaw) { Enable-ScheduledTask -InputObject $task | Out-Null }
if (!$ResumeInterrupted -and (Test-Path -LiteralPath $candidate)) { Remove-Item -LiteralPath $candidate }
}
+34 -11
View File
@@ -32,10 +32,15 @@ RUNTIME_INDEX = 'e49231e72aff7b001189b8507200c6c701f73e47f77c29194116cf1da41ca0c
COMPONENT_INDEX = '005317e652f50de3e1277be3bc42717318226208015e7c8011e1b73469cc7562'
ORIGINAL_RESULT = 'd5c4996821911a5bdac5014e9f985c56bbb592b803f2e33411dd28bb986b8eed'
ORIGINAL_INTENT = '374adc97bec41bd798409f7c4f8c7716b085e20d2b6fb64b33f7ab675e6483e2'
CANDIDATE = ROOT / 'devstate/windows-signed-clock/trusted-os-candidate-link-542cbf43-afb2-4994-b141-06e003e5e2e8'
CANDIDATE_RECEIPT = '04ed34e6e850aca77c1fd4677ddb271f7ccd9492a97f5d4e00ead4c1f032f29d'
QUALIFICATION = '96b05fe13f4d459b4b3ef78292beea33827b1ea47293ffb5921c685940e82a4d'
NEW_AGENT = '26dc9d2f6928c5a41050ac9324e041c065e7a9ae52324416f3bb6222c002ae6b'
HELPER_CANDIDATE = ROOT / 'devstate/windows-signed-clock/trusted-os-candidate-link-542cbf43-afb2-4994-b141-06e003e5e2e8'
HELPER_RECEIPT = '04ed34e6e850aca77c1fd4677ddb271f7ccd9492a97f5d4e00ead4c1f032f29d'
HELPER_QUALIFICATION = '96b05fe13f4d459b4b3ef78292beea33827b1ea47293ffb5921c685940e82a4d'
CANDIDATE = MAIN / 'devstate/windows-client/operator-window-20261115/observed-agent-build'
# Closed until Root supplies the actual completed native qualification receipt.
CANDIDATE_RECEIPT = 'f04024f78c2f11f5c66bbdf9278467f5bcc50da5c2bd7336623851bca42dd446'
QUALIFICATION = 'f04024f78c2f11f5c66bbdf9278467f5bcc50da5c2bd7336623851bca42dd446'
SOURCE_INPUTS = '11717fab51bd1d6bf103b1821cc1e2a84699f46cac21f2cc614acf4b68381fa4'
NEW_AGENT = '0549d9ebea73cff996938f859b92192cc333de194128d7c6859a3f1d2e85893c'
NEW_HELPER = '59675a3cbb3a5d213fc764f38379d6b81baaf9d47a7124470cc2767d4985763e'
PROBE = '727732fb4b38ac5431a330527bd52a3ab80af8f189ae75a7b48eceb1d4b69cac'
SYSTEM_PROBE = '77a344912c61b7ac4a92152ae1b534ca7c36fe6f7dc4675783f20558c3a7f434'
@@ -77,6 +82,15 @@ def controller():
r'''function CanonicalStateValue($value,[int]$depth=0){
if($depth-gt40){throw 'Bounded state comparison depth'}
if($null-eq$value){return $null}
# ETS wrapping does not turn a CLR JSON scalar into a JSON object.
$base=$value.PSObject.BaseObject;$culture=[Globalization.CultureInfo]::InvariantCulture
if($base-is[string]){return [string]::new($base.ToCharArray())}
if($base-is[char]){return [string]::new([char[]]@($base))}
if($base-is[bool]){return [bool]::Parse($base.ToString())}
if($base-is[sbyte]-or$base-is[int16]-or$base-is[int32]-or$base-is[int64]){return [int64]::Parse($base.ToString($culture),$culture)}
if($base-is[byte]-or$base-is[uint16]-or$base-is[uint32]-or$base-is[uint64]){return [uint64]::Parse($base.ToString($culture),$culture)}
if($base-is[single]-or$base-is[double]){$number=[double]::Parse($base.ToString('R',$culture),$culture);if([double]::IsNaN($number)-or[double]::IsInfinity($number)){throw 'Finite JSON state number required'};return $number}
if($base-is[decimal]){return [decimal]::Parse($base.ToString($culture),$culture)}
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()}
@@ -169,6 +183,7 @@ def write(path, raw):
def prepare(script):
require(type(CANDIDATE_RECEIPT) is str and len(CANDIDATE_RECEIPT)==64 and QUALIFICATION==CANDIDATE_RECEIPT,'actual final native agent qualification receipt not yet bound')
result, old_intent, settings, pin, policy = original()
grant = prior.cb.contract.protected_json(MAIN/'credentials/windows-dev-access.json')
expiry = grant.get('expires_at')
@@ -177,11 +192,18 @@ def prepare(script):
deadline = dt.datetime.fromisoformat(expiry.replace('Z','+00:00'))
require((deadline-dt.datetime.now(dt.timezone.utc)).total_seconds() >= 420,'current authorization window has insufficient total maintenance/readback budget')
receipt = protected(CANDIDATE/'receipt.json', CANDIDATE_RECEIPT)
require(receipt['source_receipt_sha256'] == QUALIFICATION and receipt['input_count'] == 202
and receipt['link_exit'] == 0 and receipt['target_called'] is False
and receipt['artifacts']['rmm-agent-windows.exe']['sha256'] == NEW_AGENT
and receipt['artifacts']['rmm-helper-windows.exe']['sha256'] == NEW_HELPER,
'actual new offline-linked freshness pair, no native qualification inferred')
helper_receipt = protected(HELPER_CANDIDATE/'receipt.json', HELPER_RECEIPT)
require(receipt['source_inputs_sha256']==SOURCE_INPUTS and receipt['source_verified_before_after'] is True
and receipt['link_exit']==0 and receipt['original_helper_sha256']==NEW_HELPER
and receipt['artifacts']['rmm-agent-windows.exe']['sha256']==NEW_AGENT,
'actual final source-verified locally linked and natively qualified passive agent')
require(helper_receipt['source_receipt_sha256']==HELPER_QUALIFICATION and helper_receipt['link_exit']==0
and helper_receipt['artifacts']['rmm-helper-windows.exe']['sha256']==NEW_HELPER,
'unchanged independently linked original helper')
artifact_sources={'rmm-agent-windows.exe':CANDIDATE/'rmm-agent-windows.exe',
'rmm-helper-windows.exe':HELPER_CANDIDATE/'rmm-helper-windows.exe'}
artifacts={'rmm-agent-windows.exe':receipt['artifacts']['rmm-agent-windows.exe'],
'rmm-helper-windows.exe':helper_receipt['artifacts']['rmm-helper-windows.exe']}
ident = str(uuid.uuid4()); folder = STATE/ident; folder.mkdir(mode=0o700,parents=True)
script_sha = raw_sha(script.encode())
draft = dict(id=ident,access_expiry_utc=expiry,old_agent=OLD_AGENT,old_helper=OLD_HELPER,old_policy=OLD_POLICY,old_pin=OLD_PIN,
@@ -196,7 +218,7 @@ def prepare(script):
for name,raw in items.items():
write(folder/name,raw);files[name]=dict(bytes=len(raw),sha256=raw_sha(raw))
for name,expected in [('rmm-agent-windows.exe',NEW_AGENT),('rmm-helper-windows.exe',NEW_HELPER)]:
source=CANDIDATE/name;metadata=source.lstat()
source=artifact_sources[name];metadata=source.lstat()
require(metadata.st_nlink == 1 and metadata.st_mode&0o777 == 0o500 and sha(source) == expected,
'exact private linked candidate artifact')
dependencies=prior.dependencies();dependencies[str(Path(prior.__file__).relative_to(ROOT))]=PRIOR_SOURCE
@@ -205,7 +227,8 @@ def prepare(script):
original_case=OLD_CASE,original_result_sha256=ORIGINAL_RESULT,original_intent_sha256=ORIGINAL_INTENT,
original_runtime_index_sha256=RUNTIME_INDEX,original_component_index_sha256=COMPONENT_INDEX,
candidate_receipt_sha256=CANDIDATE_RECEIPT,qualification_sha256=QUALIFICATION,
artifacts={name:receipt['artifacts'][name] for name in ('rmm-agent-windows.exe','rmm-helper-windows.exe')},
artifacts=artifacts,helper_receipt_sha256=HELPER_RECEIPT,helper_qualification_sha256=HELPER_QUALIFICATION,source_inputs_sha256=SOURCE_INPUTS,
linux_result_sha256=receipt['linux_result_sha256'],windows_result_sha256=receipt['windows_result_sha256'],
access_expiry_utc=expiry,access_expiry_source='protected current windows-dev-access.json public expires_at; exact VM account/bootstrap-public match before effects',
server_qualification_bound=True,enter_enabled=True,time_configuration_created=False,
calibration_created=False,target_called=False,main_indices_modified=False,
+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()
+519
View File
@@ -0,0 +1,519 @@
#!/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
$installNotBefore=[DateTime]::UtcNow.ToString('o')
NewPrivateCase
WriteNew (Join-Path $folder 'intent.json') @{id=$request.id;request=$request;before=$before;original_root_sddl=$rootSddl;install_not_before=$installNotBefore;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;install_not_before=$installNotBefore;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}
# ETS wrapping does not turn a CLR JSON scalar into a JSON object.
$base=$value.PSObject.BaseObject;$culture=[Globalization.CultureInfo]::InvariantCulture
if($base-is[string]){return [string]::new($base.ToCharArray())}
if($base-is[char]){return [string]::new([char[]]@($base))}
if($base-is[bool]){return [bool]::Parse($base.ToString())}
if($base-is[sbyte]-or$base-is[int16]-or$base-is[int32]-or$base-is[int64]){return [int64]::Parse($base.ToString($culture),$culture)}
if($base-is[byte]-or$base-is[uint16]-or$base-is[uint32]-or$base-is[uint64]){return [uint64]::Parse($base.ToString($culture),$culture)}
if($base-is[single]-or$base-is[double]){$number=[double]::Parse($base.ToString('R',$culture),$culture);if([double]::IsNaN($number)-or[double]::IsInfinity($number)){throw 'Finite JSON state number required'};return $number}
if($base-is[decimal]){return [decimal]::Parse($base.ToString($culture),$culture)}
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)
+89
View File
@@ -0,0 +1,89 @@
# Migration0016: passives Updateinventar annehmen
Am2026-11-15 ist Migration0016 tatsächlich auf dem permanenten Server mit dem
regulären SQLx-Migrationspfad ausgeführt und separat nachgelesen worden. Der
bisherige Check `observations_source_id_check` ließ nur `linux.base` und
`windows.base` zu. Die laufende Gatewayversion kannte bereits die passive
`agent.update`-Beobachtung; der Datenbankcheck verweigerte deren Speicherung.
Nach dem neuen Windowsagentenwechsel waren15 entsprechende Fehler beobachtet
worden. Diese verweigerten Nachrichten werden nicht nachträglich als gespeichert
ausgegeben.
Die additive Datei `migrations/0016_agent_update_observation_scope.sql` erweitert
ausschließlich diese feste Dreiermenge. Freie Scopes bleiben verboten. Im
normalen SQLx-Transactionrahmen wird der alte Check ersetzt und der neue Check
validiert; ein Fehler rollt die Transaktion zurück. `lock_timeout=3s` begrenzt
das Warten auf Tabellenlocks, `statement_timeout=15s` jedes DDL-Statement.
Keine DML-, RLS-, FK-, PK-, Tenant-/Geräte-/Zertifikats-, Job-, Grant- oder
Policyänderung gehört zur Migration.
Tatsächlicher Fall: `cc3ea56d-6186-425a-8ef3-90562212fb1b`. Verwendet wurde das
bereits vom Orchestrator nativ ARM64 gebaute Image
`sha256:6a76343bf65c126458244f5540d4cb740988144fc77877b409f790251e7ddcc7`.
Es enthält den vorhandenen `rmm-server migrate`-Entrypoint und die echte
SQLx-`migrate!`-Migrationseinbettung. Es wurde kein zusätzlicher Builderlauf
gestartet und keine SQLx-Tabellenzeile manuell angelegt oder geändert.
Ein eigenes privates Compose-Overlay wählte ausschließlich für den temporären
`migrate`-Container dieses bereits vorhandene Image (`pull_policy: never`,
read-only RootFS, CapDropALL, NoNewPrivileges). Die vorhandene Migration-URL
blieb im normalen Compose-/Prozesskontext; sie wurde nicht ausgegeben. Der
unterstützte `docker compose … run --no-deps … migrate` führte genau einen
wirklichen SQLx-Lauf aus, Exit0. Der eigene gestoppte Container wurde nach
seinem Exit-/Image-/Falllabelbeleg entfernt. Kein API-, Gateway- oder
PostgreSQLdienst wurde durch diesen Agenten ersetzt oder neu gestartet.
API-Filterung und API-only-Deployment sind ein eigener Orchestratorschnitt.
Die tatsächliche SQLx-Historie besitzt danach Versionen1–16 jeweils mit
`success=true`; die alten15 Checksums stimmen unverändert mit den Quellinputs
überein. Version16 heißt `agent update observation scope` und besitzt SHA384
`e66ec49233c210555b5107d20b925ca6715925871aa2bf94dfb86bd5cfb39c6dc769fdf0049b615fcad503332e1cd8fc`.
Die SQL-Datei hat SHA256
`fa0953262e3a8da7f3f0366db6f3fa77ad7976ec04327b126036739eea46eebb`.
Vor dem echten SQLx-Start wurden3127 bestehende Observationzeilen serverseitig
über ihre vollständige JSON-Zeilendarstellung gehasht; unmittelbar danach waren alle
unverändert. Der ursprüngliche Fallbaseline enthielt3123Zeilen. Deren
unveränderte Fingerprints und die vollständige RLS-/Owner-/ACL-/Policy-,
FK-/PK-/sonstige Check- und Job-/Plan-/Authorization-/Outbox-/Permit-/Receipt-
Zeugen wurden nochmals in einem getrennten Read-only-SQL-Aufruf bestätigt.
Neue passive Zeilen durften parallel regulär hinzukommen. Die neue Constraint
war tatsächlich `VALIDATED` und enthielt genau
`linux.base`, `windows.base`, `agent.update`. API und Gateway liefen während
dieser Migration unverändert mit Image422c2c28; PostgreSQL behielt seine
ursprüngliche Container-/Imageidentität.
Ein weiterer lesender Serverabgleich fand bereits drei angenommene
`agent.update`-Zeilen, zuletzt15:40:50UTC. Das beweist die normale Speicherung
dieses Scopes nach der Migration, keinen separat geprüften Windows-ACK,
keine neue Basisinventarabnahme und keine Zeit-/Jobbereitschaft.
Die Vorherarchive enthalten Katalog-/Migrations-/Policyzeugen und
Zeilenfingerprints; ein vollständiger **Vorher-`pg_dump` wurde nicht angelegt**.
Ein vollständiger privater Customformat-Dump wurde ausdrücklich **nach** der
Migration archiviert: `after-migration-0016.pg_dump`,49,455,447Bytes, SHA256
`b89e74eaaea7ec2faa17a44358acca3aead1db0fcf9ccf673e2c5808b3259398`.
Er bleibt ausschließlich im Root0700-Fall auf dem Server, Datei0600, und wurde
nicht heruntergeladen oder als Vorherbackup bezeichnet. Ein Restoretest wurde
hier nicht ausgeführt.
Zwei harmlose Vorbedingungen scheiterten vor dem eigentlichen SQLx-Lauf und
bleiben erhalten: zunächst die Annahme eines vollständigen Buildkontexts
statt des tatsächlichen Minimal-Kontexts; danach ein hier nicht unterstütztes
Compose-Flag `--no-build`. Für letzteren Fall waren Exit1, Ledger15 und die
Abwesenheit eines eigenen Containers belegt. Nach Roots konkreter Korrektur
wurde derselbe Originalfall mit einem neuen Create-only-Fortsetzungsintent
verwendet; alte Fehler-/Vorherdateien wurden nicht überschrieben. Ein weiterer
reiner Absenzmatcher wurde an die tatsächliche Kleinschreibung der Docker-
Fehlermeldung angepasst, ebenfalls vor jedem Container-/SQLx-Start. Keine
verlorene SQLx-Wirkung wurde blind wiederholt.
Geschütztes Serverarchiv:
`/opt/rust-discovery/devstate/observation-scope-migration-cc3ea56d-6186-425a-8ef3-90562212fb1b/`.
Lokaler Belegordner im eigenen Worktree:
`devstate/observation-scope-migration/cc3ea56d-6186-425a-8ef3-90562212fb1b/`.
Die separate lokale `receipt.json` bindet Originalintent, Fehler, tatsächlichen
SQLx-Erfolg, getrennten Read und Nachbackup; SHA256
`00ff8f8ffa689bf3917937ce14ae23457e464b921ae7793e9091eab9a83d76c7`.
Private Zugangsdaten und
Datenbankinhalte wurden weder veröffentlicht noch in Git aufgenommen.
+13 -7
View File
@@ -6,15 +6,21 @@ Mandant und eine alte Verbindung wurden abgewiesen. Die Cloud-Linux-VM und
der Windowsgast melden sich selbständig und sind über MCP abrufbar.
[Gateway](server-time-gateway-deploy.md) · [Windows-Protokolltest](windows-time-route-operator.md)
Die bestehende Windows-Dienstinstallation ist weiterhin passiv und online.
Der vorbereitete Dienstwechsel benötigt ein neues befristetes Wartungsfenster.
Danach folgen der Zeitabgleich in den beiden Dienstprozessen und der erste
in der WebUI genehmigte Windows-Skriptauftrag mit Ausgabe.
[Stand des Dienstwechsels](windows-signed-clock-upgrade-plan.md)
Nach dem Ruhezustand des Notebooks meldete der Windows-Agent um 15:47:51 Uhr
MEZ über den permanenten Server wieder `online`. Der SSH-Tunnel für die
Entwicklung hing und wurde geschlossen. Zum Fortsetzen des Dienstwechsels
muss die Bedienperson das Fenster auf der Windows-Konsole erneut öffnen.
Der vorbereitete Agent wurde aus seinem festgehaltenen Quellstand für AMD64
gebaut. Neun gezielte Zeitprüfungen daraus bestanden auf beiden Test-VMs.
Der tatsächliche Dienstwechsel, die Zeitprüfung in beiden installierten Rollen
und der erste über die WebUI genehmigte PowerShell-Auftrag stehen aus.
[Wartungsfenster](windows-dev-access-recovery.md) · [Dienstwechsel](windows-signed-clock-upgrade-plan.md)
Die passive Zertifikatserneuerung ist implementiert. Fünf Wiederanlauf- und
Fehlerfälle mit Testidentitäten bestanden auch auf Windows. Die Erneuerung
durch den installierten LocalService-Dienst steht aus.
Fehlerfälle mit Testidentitäten bestanden auch auf Windows. Das Anlegen,
Schützen und Wiederöffnen einer separaten Testschlüsseldatei bestand auf
der Windows-VM unter dem Entwicklungskonto. Die Erneuerung durch den
installierten LocalService-Dienst steht aus.
[Zertifikatserneuerung](windows-certificate-renewal.md)
Der Linux-Agent kann einen signierten Releasekatalog über mTLS prüfen und das
+11
View File
@@ -1,5 +1,16 @@
# Tatsächlicher Implementierungsstand
## Agent-Update-Telemetrie: Migration0016 tatsächlich angewendet — 2026-11-15
Der permanente Server akzeptiert nun zusätzlich den festen passiven Scope
`agent.update`. Regulärer SQLx-Runner aus dem vorhandenen ARM64-Kandidaten6a7634,
Exit0 und separate Read-only-Nachprüfung von Version16/Checksum/VALIDATED-Check
bestanden. Ursprüngliche Zeilen, RLS/FKs/PK/ACL und Corezeugen erhalten; keine
laufenden Dienste durch diesen Schnitt ersetzt. Erste drei regulär angenommene
Updatebeobachtungen belegt. API-Basisfilterung ist getrennt. Vorherfingerprints
und ausdrücklich erst nachher angelegter privater pg_dump sind dokumentiert;
kein vorgetäuschter Vorherbackup-/Restoretest. [Beleg](agent-update-observation-scope.md).
## Passiver Windows-Zeitabschluss vorbereitet — 2026-11-15
Ein kleiner rein lesender Collector für die beiden historischen Rollenbelege
+49
View File
@@ -289,3 +289,52 @@ Autostarttask. Beide installierten Dienste liefen beim Readback mit ihren
bisherigen Prozess-IDs: Agent 5528 als LocalService, Helper 9464 als LocalSystem.
Danach wurde die Ablaufzeit im lokalen Zugangsdatensatz an die geprüfte
Gastfrist angepasst. Dies ist der Nachweis für den Entwicklungszugang.
### Unterbrechung nach Ruhezustand des Notebooks
Das Hostjournal belegt Suspend zwischen 14:48:24 und 15:39:01 Uhr MEZ.
Danach blieb die Windows-VM im KVM-Status `running`. Der Entwicklungszugang
lieferte bei der SSH-Begrüßung einen Timeout. Auch direkt am bestätigten
Loopback-Listener des Servers kam keine Begrüßung an. Um 15:47 Uhr wurde
nur die anhand von Konto, Prozess und Listener erneut identifizierte alte
Forwarding-Sitzung geschlossen. Schlüssel und vereinbarte Frist von
16:30 Uhr MEZ blieben erhalten. Zum erneuten Aufbau ist die VM-Konsole nötig.
Der Produktagent meldete sich nach dem Resume beim permanenten Server. MCP
lieferte bei der Abfrage um 15:48 Uhr MEZ für den Windows-Gast `online`,
Quelle `windows.base`, letzter Kontakt 15:47:51 Uhr MEZ. Beim Unterbruch war
der Dienstwechsel noch nicht in die Ausführungsphase gelangt.
Eine weitere reine MCP-Abfrage bestätigte das nach dem Aufwachen neu
eingegangene Windows-Inventar. Beobachtungszeit 15:39:13 Uhr MEZ, späterer
Kontakt 15:52:23 Uhr MEZ. Betriebssystem, Volumes, Hardware und Software
lagen jeweils als `valid/partial` vor. CPU-Anzahl, Verhältnis von freiem zu
gesamtem Speicher und die Volumenwerte bestanden die Plausibilitätsprüfung.
Windows-Inodes waren ausdrücklich `unsupported` mit leerem Zahlenwert.
Beleg-SHA-256 `cce907d4c5e4ca9b788bab4aad8aac1f082b59f6a2922484289f19be061a1162`.
Die Abfrage nutzte gespeicherte Telemetrie und erforderte keine SSH-Verbindung.
Beim erneuten Konsolenstart meldete der Gast die Sammelmeldung
`Unexpected account, task, server or previous expiry.`. Sie stammt aus der
Vorprüfung vor der ersten Änderung. Welcher Gastwert abweicht, steht bis zum
Konsolen-Readback offen. Die Serverfrist wurde zu diesem Zeitpunkt nochmals
mit 15:30 UTC bestätigt. Neuere Versionen des Konsolenskripts benennen die
abweichenden Felder einzeln. Drei lokal simulierte Vorprüfungen bestanden
(Ausgangszustand, drei abweichende Werte, alle sechs Bedingungen abweichend).
Der Konsolenreadback vom 15. November um 15:59:11 Uhr MEZ ergab
`Disabled`, aktives Konto, Konto und Konfiguration beide mit Frist 16:30 Uhr
MEZ, passender Servername, laufender sshd und genau eine ausstehende Sicherung.
Der Bediener kann diesen konkreten Zustand mit `-ResumeInterrupted` im selben
Zeitfenster übernehmen. Das Skript prüft die ursprüngliche Frist der Sicherung
und rekonstruiert daraus die aktuelle Konfiguration. Bereits laufende
Wartungsprozesse verhindern einen Doppelstart. Bei regulärem Ende verwendet
es die ursprüngliche Sicherung zur Rücksetzung. Lokaler Parser- und Fixturetest
für passende Sicherung, aktiven Prozess, Konfigurations- und Fristabweichungen
bestanden. Die Wiederaufnahme muss auf der Windows-Konsole erfolgen.
Um 16:04:25 Uhr MEZ war der Windows-Gast über die vom Bediener wieder
geöffnete Verbindung erreichbar. Der Gast bestätigte für Konto und Konfiguration
denselben Ablauf um 16:30 Uhr MEZ, den erwarteten Servernamen und den
deaktivierten Autostarttask. Agent und Helper liefen weiterhin mit ihren
ursprünglichen PIDs 5528 und 9464 als LocalService beziehungsweise LocalSystem.
+102
View File
@@ -247,3 +247,105 @@ Der Agent-Zwischenbuild `34b7458d…` wurde nicht installiert.
Die neun gezielten Zeitprüfungen aus diesem konkreten Quellstand bestanden auf
der Cloud-Linux-VM als UID 65534, Exit 0. SHA-256 der Ergebnisquittung
`333f8d2dba3b35dcd79faafd8faf5c88da321942c9672c0a80f1f2c8fceb24a3`.
Anschließend bestanden die gleichen neun Tests auf der Windows-VM aus dem
separat gebauten AMD64-Librarytestbinary desselben Release-Quellstands, Exit 0.
Die Ergebnisquittung hat SHA-256
`7700096145afdca74e7473e56c6dd2e65651252e889a696f84bb1fc2441ff513`.
Nach erneutem Abgleich aller 202 Quelldateien, des PE-Headers und des Helperhashs
wurde das Buildreceipt
`f04024f78c2f11f5c66bbdf9278467f5bcc50da5c2bd7336623851bca42dd446`
für den einmaligen Dienstwechsel erstellt. Der Windows-Testprozess hat weder
einen Dienst ausgetauscht noch einen Agentjob ausgeführt.
Der exakt gebaute Quellstand für das neue Agentbild liegt in Gitea auf
`codex/windows-passive-time-candidate`, Commit
`c6c4037d072a96d62136264066d0257782c7a932`. Alle 202 Build-Inputs wurden
byteweise mit dem Release-Manifest abgeglichen. Der Ausgangsstand der
ursprünglichen Qualifikation entspricht für dieselben 202 Dateien
`b8ca8266bbb3b4806f4d20a3039f25196638804e`.
## Endgültiger passiver Agent und erneute Transportverweigerung
Root qualifizierte für genau den beobachtbaren passiven Stand cc82124 den
Agent0549d9ebea73cff996938f859b92192cc333de194128d7c6859a3f1d2e85893c.
Tatsächliche Linux9-/Windows9-Guards und Release-Link sind im Receipt
f04024f78c2f11f5c66bbdf9278467f5bcc50da5c2bd7336623851bca42dd446 gebunden,
Sourceinputs11717fab51bd1d6bf103b1821cc1e2a84699f46cac21f2cc614acf4b68381fa4.
Helper5967… bleibt aus dem ursprünglichen04ed-Produktreceipt unverändert.
Der Generator bindet diese beiden getrennten tatsächlichen Artefaktquellen,
keinen nochmals eingebauten26dc-Agenten. Der öffentliche neue lokale Receipt
war zunächst0664; nur sein Modus wurde auf0600 gehärtet, Bytes/SHA unverändert.
Neuer unveränderlicher Fall570c7a86-6509-49e6-b95e-8f0df74b18bf,
Controller67d2fb1f9fdfec05b08f53a37be9a7df4cc3bb39f6cde8f950a226286474fd45,
bindet das bestätigte15:30UTC-Fenster. Sein allererster kleiner Stage-Read wurde
jedoch bereits beim SSHtransport verweigert: return255, stdout0, stderr89Bytes.
Ein einzelner begrenzter Statusversuch klassifizierte CONNECTION_TIMEOUT,
keinen Authentifizierungs-/Hostkeyfehler. Kein neuer Agenttransfer, kein Enter,
keine Dienständerung oder Wiederholung unklarer Wirkung durch diesen Fall.
Root belegte danach Notebook-System-Suspend13:48:24–14:39:01UTC und einen nicht
mehr antwortenden alten Forwardingkanal. Damals existierte weiterhin keine
V2-Konfiguration/Zeitauthorität; beide ursprünglichen Produktdienste waren passiv.
Root beendete ausschließlich den separat kernelgebundenen alten Bastionforwarder
und forderte kontrolliertes Neuöffnen desselben Fensters an. Dieser Wartungsagent
änderte weder Tunnel, Konto, Schlüssel noch SSHkonfiguration. Seit Roots Sperre
keine weiteren VM-Aufrufe bis bestätigtem Transportreadback.
Abschließender lokaler Check: Pythoncompile, bestehende Quellguards, exakte
saved-controller-/Generatorbytes, neues Agentimage, unverändertes Helperimage,
Source-/Native-Receipt und geschützte15:30-Payloadbindung PASS. Beleg
74ca4c2572872eb64cecc250aefd4bbffa5d8e4dc9b3729b5b83c19ac07a670f,
`final-local-check.json` im570c-Fall. Neue native Baseline, tatsächlicher
Paarwechsel und unabhängige Nachlese bleiben offen. Es wird kein Windowsabschluss
oder funktionierender installierter Zeitvergleich behauptet.
## Transport wieder bestätigt: endgültiger570c-Stand nativ bereit
Nach Roots tatsächlichem Konsolen-/Transportreadback15:04:25UTC wurde ausschließlich
der vorhandene570c-Fall fortgesetzt, unverändertes Ende15:30UTC. Tatsächliche
Stagebestätigung für Helper5967…, endgültigen Agent0549… und Controller67d2…
bestanden. Volle neue native Baseline bestätigt ursprüngliche Running-PIDs5528/9464,
unveränderte config/PKI/ACLs und vollständigen bisherigen Helper-DB-/Lock-/Intent-
zustand. BaselineSHA
b1a7928f89ad2bb9c63720dedea6f343d644c9882052877b5144dc200537f5e7.
Geschlossene Serverflags und Windows0-/Linux31/31/27-Zähler unverändert.
Noch keine Dienständerung bis zu diesem Baselinebeleg. Nächster Schritt ist die
genau einmalige, an diese neuen tatsächlichen Bytes gebundene Enterphase.
## ETS-Skalartypfehler vor erster Wirkung behoben
Die einmalige570c-Enterphase verweigerte `Original SCM invariant`. Die reine
Nachlese zeigt erneut eigenen Ordner/active-intent und alle Stopmarker absent;
Originaldienste laufen5528/9464. Keine Enterwiederholung und keine Dienstwirkung.
Isolierter Vergleich aller sechs SCM-Felder inklusive CLR-/Basistyp und Wrapping
belegt ausschließlich `sid_type`: Baseline und live beide System.Int32=1, aber
der ETS-wrapped Registrywert erfüllt zusätzlich `-is[pscustomobject]` und wurde
irrtümlich zu `{}` normalisiert. Die anderen fünf Felder stimmten exakt überein.
Der Vergleich rekonstruiert jetzt JSON-Skalare aus ihrem CLR-Basiswert vor dem
Objektpfad (primitive Strings/Bool/Integer/finite Double/Decimal), ohne ETS-Notes
als fachlichen Objektinhalt umzudeuten. Echte JSON-Objekte behalten alle Keys;
Casekollisionen/Arrayreihenfolge/Null/Tiefengrenze bleiben geschützt. Unabhängiger
enger Review der Quelle90c2708c… ohne weiteren konkreten Befund.
Tatsächlich anschließend auf derselben VM: vollständiges originales
`SameOriginal` gegen gespeicherte Baseline und frischen LiveState bestanden.
Zusätzlich native ETS-Add-Member-Fälle für Integer/String/Bool gleich,
Scalaränderung/Arrayumkehr/Null gegenüber leerem Array weiterhin verweigert.
Result82c4ebe75bff95005ebd946ae99e206ec69648bec93adb17cf683c46fc46212a,
`typed-full-pre-effect-comparison.json` im570c-Fall. Weiterhin keine Ordner/active-
Marker und keine Dienständerung. Neuer Controllerfall folgt getrennt;570c bleibt
als fehlgeschlagene Vorwirkungsphase erhalten.
## Neuer typkorrigierter Fall4887 nativ bereit
Fall4887940a-4c9c-4807-aaf2-6fbc94faad46 bindet unverändert Agent0549/Helper5967,
denselben echten Quell-/Linux9-/Windows9-Beleg und das unveränderte15:30-Fenster.
Controller66ca45e15e8f790c4614db74dd491137d5e28104e2d28ee658cc287debcd021f.
Alle festen Stagebytes erneut nativ bestätigt; volle frische Baseline einschließlich
ursprünglicher PIDs5528/9464, config/PKI/ACLs und Helper-DB/Lock/Intents bestanden.
Baseline00bf31bd5355dc77e0aadd73d2ab57ea32410956ef764f3f2aeb195bd218479e.
Geschlossene Servergates unverändert, bis hier weiterhin kein Serviceeffekt.
4887 besitzt noch keinen Enterversuch;570c bleibt getrennt vor Wirkung verweigert.
+133
View File
@@ -0,0 +1,133 @@
# 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.
Unmittelbar vor der ersten Erstellung wird `install_not_before` aus der
nativen VM-UTC gelesen und im ursprünglichen Intent sowie Ergebnis erhalten.
Das ist eine Herkunftsuntergrenze für die nachfolgende separate Nachlese und
den passiven Collector, keine eigenständige Uhrvertrauensbehauptung.
## 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.
- Lokale ETS-Integer-/Bool-/String-Reproduktion sowie Objekt-/Arrayreihenfolge:
PASS. Der unveränderte Vergleich aus `e6debe5` war unter Windows PowerShell 5
unzureichend: ETS-verpacktes `System.Int32=1` konnte im Objektzweig zu `{}`
werden. Der exakt übernommene Comparator aus der getrennt geprüften
Clockquelle `90c2708c…` rekonstruiert CLR-Skalare vor dem Objektzweig als
unadornierte Werte. Der Clockoperator hat diesen Vergleich außerdem tatsächlich
gegen den vollständigen alten Livezustand und ETS-Positiv-/Negativfälle
geprüft (`82c4ebe7…`). Das ist kein Profilinstallationsnachweis.
- 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.
@@ -0,0 +1,9 @@
-- Passive agent-update observations share the existing tenant/device-bound
-- ingest path. Preserve both base scopes and every existing row/RLS/FK.
-- SQLx applies this file transactionally and records its normal checksum.
SET LOCAL lock_timeout = '3s';
SET LOCAL statement_timeout = '15s';
ALTER TABLE observations DROP CONSTRAINT observations_source_id_check;
ALTER TABLE observations ADD CONSTRAINT observations_source_id_check
CHECK (source_id IN ('linux.base', 'windows.base', 'agent.update')) NOT VALID;
ALTER TABLE observations VALIDATE CONSTRAINT observations_source_id_check;