Files
rust-discovery/deploy/windows/system_delegation_acceptance.py
2026-11-14 07:43:36 +01:00

279 lines
18 KiB
Python

#!/usr/bin/env python3
"""Separate source-bound Windows delegation build/native units; no deployment.
Historical feature profiles stay unchanged. Unit execution is create-once;
lost replies permit same-case readback only. No RMM requests or approvals.
"""
import argparse
import base64
import hashlib
import json
import os
from pathlib import Path
import re
import shutil
import stat
import subprocess
import uuid
import client_bootstrap as cb
import runtime_feature_upgrade as feature
import runtime_upgrade as previous
import auto_transport_acceptance as auto
require = cb.contract.require
STATE = cb.EVIDENCE / 'system-delegation-acceptance'
CORE = cb.ROOT / 'devstate/core-no-start/build-de37ee99-11bf-465b-9519-45ad8f6e5b87/manifest.json'
CORE_SHA = '1bc082031fcad20d5a519b0004f63d499dbba2ea9ce25d56230d48d2556d474b'
# Final source review must confirm these before a build. No minimum-count proof.
COUNTS = {'lib': 23, 'bin': 7}
NAMES = {'agent': 'rmm-agent-windows.exe', 'helper': 'rmm-helper-windows.exe',
'probe': 'RuntimeStateProbe.exe', 'system_probe': 'SystemStateProbe.exe',
'lib': 'windows-tests-lib.exe', 'bin': 'windows-tests-bin.exe'}
TARGET = previous.TARGET
def sha(path):
return hashlib.sha256(Path(path).read_bytes()).hexdigest()
def save(path, value):
path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
cb.contract.write_private(path, value)
def sources():
result = feature.source_files()
for path in (cb.ROOT / 'crates').glob('*/Cargo.toml'):
result[str(path.relative_to(cb.ROOT))] = sha(path)
for name in ('deploy/windows/system_delegation_acceptance.py',
'deploy/windows/client_bootstrap.py',
'deploy/windows/system_intent_bootstrap.py'):
result[name] = sha(cb.ROOT / name)
return dict(sorted(result.items()))
def core_proof():
require(sha(CORE) == CORE_SHA, 'exact Linux-first core manifest')
manifest = cb.contract.protected_json(CORE)
result = {'manifest_sha256': CORE_SHA}
for platform, count in (('linux', 80), ('windows', 58)):
path = CORE.parent / (platform + '-passed.json')
proof = cb.contract.protected_json(path)
require(proof['verified'] is True and proof['platform'] == platform
and proof['manifest_sha256'] == CORE_SHA, 'actual same-manifest native core proof')
actual = proof['native']['reports']
require(set(actual) == set(manifest['test_counts'][platform]), 'all core artifacts')
require(sum(len(v['names']) for v in actual.values()) == count, 'full native core lists')
for kind, item in actual.items():
output = base64.b64decode(item['stdout_b64'], validate=True)
n = manifest['test_counts'][platform][kind]
require(item['exit_code'] == 0 and item['timed_out'] is False
and item['names'] == manifest['test_names'][platform][kind]
and item['sha256'] == manifest['artifacts'][platform][kind]['sha256']
and re.search(rb'test result: ok\. ' + str(n).encode()
+ rb' passed; 0 failed; 0 ignored; 0 measured; 0 filtered out;', output),
'actual complete native core results')
result[platform] = {'proof_sha256': sha(path), 'case_id': proof['case_id']}
for name, digest in manifest['source_files'].items():
if name.startswith(('crates/agent-core/', 'crates/domain/', 'crates/protocol/', 'proto/')):
require(sha(cb.ROOT / name) == digest, 'native-qualified common source unchanged')
return result
def command(args, timeout=600):
value = subprocess.run(args, capture_output=True, timeout=timeout)
if value.returncode:
folder = STATE / ('local-command-failure-' + str(uuid.uuid4()))
folder.mkdir(mode=0o700, parents=True)
save(folder / 'result.json', {'returncode': value.returncode, 'local_build_only': True})
for name, data in (('stdout.bin', value.stdout), ('stderr.bin', value.stderr)):
descriptor = os.open(folder / name, os.O_CREAT | os.O_EXCL | os.O_WRONLY | os.O_NOFOLLOW, 0o600)
with os.fdopen(descriptor, 'wb') as stream:
stream.write(data)
require(value.returncode == 0, 'local qualification command failed')
return value.stdout
def build():
os.umask(0o077)
before = sources()
common = core_proof()
require(re.search(r'^pub const ADAPTER_QUALIFIED: bool = false;$',
(cb.ROOT / 'crates/agent-windows/src/clock.rs').read_text(), re.M),
'production clock remains closed')
folder = STATE / ('build-' + str(uuid.uuid4()))
folder.mkdir(mode=0o700, parents=True)
save(folder / 'source-before.json', before)
target = STATE / 'target'
target.mkdir(mode=0o700, exist_ok=True)
image = command(['docker', 'image', 'inspect', '--format', '{{.Id}}', previous.IMAGE]).decode().strip()
require(re.fullmatch(r'sha256:[a-f0-9]{64}', image), 'immutable build image')
docker = ['docker', 'run', '--rm', '--network', 'none', '--read-only', '--tmpfs', '/tmp:rw,size=512m',
'-v', str(cb.ROOT) + ':/src:ro', '-v', str(target) + ':/target',
'-e', 'CARGO_TARGET_DIR=/target', '--entrypoint', 'cargo', image]
options = ['--manifest-path', '/src/Cargo.toml', '--locked', '--offline', '--target', TARGET,
'-p', 'rmm-agent-windows']
command(docker + ['clippy'] + options + ['--all-targets', '--', '-D', 'warnings'])
command(docker + ['clippy'] + options + ['--features', 'system-helper', '--all-targets', '--', '-D', 'warnings'])
command(docker + ['build'] + options + ['--features', 'system-helper', '--bins', '--example',
'runtime_state', '--example', 'system_state', '--release'])
raw = command(docker + ['test'] + options + ['--features', 'system-helper', '--lib', '--bin',
'rmm-agent-windows', '--no-run', '--message-format=json'])
units = {}
for line in raw.splitlines():
try:
item = json.loads(line)
except ValueError:
continue
if item.get('reason') != 'compiler-artifact' or not item.get('profile', {}).get('test') or not item.get('executable'):
continue
if 'rmm-agent-windows' not in item['package_id']:
continue
require('system-helper' in item['features'], 'actual feature unit profile')
kind = 'lib' if 'lib' in item['target']['kind'] else 'bin'
require(kind not in units, 'exact distinct unit artifacts')
units[kind] = target / Path(item['executable']).relative_to('/target')
require(set(units) == set(COUNTS), 'both unit artifacts')
selected = {'agent': (target / TARGET / 'release/rmm-agent-windows.exe', 'rmm-agent-windows.exe'),
'helper': (target / TARGET / 'release/rmm-helper-windows.exe', 'rmm-helper-windows.exe'),
'probe': (target / TARGET / 'release/examples/runtime_state.exe', 'RuntimeStateProbe.exe'),
'system_probe': (target / TARGET / 'release/examples/system_state.exe', 'SystemStateProbe.exe')}
selected.update({kind: (path, 'windows-tests-' + kind + '.exe') for kind, path in units.items()})
artifacts = {}
for kind, (original, name) in selected.items():
path = folder / name
shutil.copyfile(original, path)
path.chmod(0o600)
linked_sha = sha(original)
retained = folder / (name + '.linked')
shutil.copyfile(original, retained)
retained.chmod(0o600)
if kind in COUNTS:
command(['docker', 'run', '--rm', '--network', 'none', '--read-only', '-v', str(folder.resolve()) + ':/artifacts',
'--entrypoint', 'x86_64-w64-mingw32-strip', image, '--strip-debug', '/artifacts/' + name])
require(sha(original) == sha(retained) == linked_sha, 'original link preserved')
data = path.read_bytes()
offset = int.from_bytes(data[60:64], 'little')
require(data[:2] == b'MZ' and data[offset:offset + 6] == b'PE\0\0\x64\x86', 'Windows AMD64 PE')
artifacts[kind] = {'path': str(path.resolve()), 'name': name, 'sha256': sha(path), 'bytes': len(data),
'original_link_path': str(retained.resolve()), 'original_link_sha256': linked_sha}
require(sources() == before and core_proof() == common, 'sources and common proofs unchanged throughout build')
manifest = {'schema_version': 1, 'type': 'rmm.windows.system-delegation-build', 'source_files': before,
'source_before_after_equal': True, 'artifacts': artifacts, 'native_counts_expected': COUNTS,
'core_native_proofs': common, 'build_image_id': image, 'default_and_feature_alltarget_clippy': True,
'production_clock_qualified': False, 'native_windows_executed': False}
save(folder / 'manifest.json', manifest)
print(json.dumps({'manifest': str((folder / 'manifest.json').resolve()), 'native_executed': False}))
SCRIPT = r'''
$ErrorActionPreference='Stop';$p=([Console]::In.ReadLine()|ConvertFrom-Json)
if([string]([guid]$p.id)-cne$p.id-or$p.action-notin@('run','read')-or$p.manifest_sha256-notmatch'^[a-f0-9]{64}$'){throw 'Fixed native delegation unit case'}
$root='C:\ProgramData\RustDiscoveryBootstrap';$case=Join-Path $root ('delegation-units-'+$p.id)
function Safe($path,$dir){$i=Get-Item -LiteralPath $path -Force;if($i.PSIsContainer-ne$dir-or($i.Attributes-band[IO.FileAttributes]::ReparsePoint)){throw 'Private unit type'};$a=Get-Acl -LiteralPath $path;if($a.GetOwner([Security.Principal.SecurityIdentifier]).Value-notin@('S-1-5-18','S-1-5-32-544')){throw 'Unit owner'};$rules=@($a.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier]));if(!$rules.Count){throw 'Empty ACL'};foreach($r in $rules){if($r.AccessControlType-ne'Allow'-or$r.IdentityReference.Value-notin@('S-1-5-18','S-1-5-32-544')){throw 'Unit ACL'}}}
function WriteNew($path,$value){$b=[Text.Encoding]::UTF8.GetBytes(($value|ConvertTo-Json -Depth 12 -Compress));$f=[IO.File]::Open($path,'CreateNew','Write','Read');try{$f.Write($b,0,$b.Length);$f.Flush($true)}finally{$f.Dispose()}}
Safe $root $true
if($p.action-eq'read'){Safe $case $true;Safe (Join-Path $case 'intent.json') $false;$i=Get-Content -LiteralPath (Join-Path $case 'intent.json') -Raw|ConvertFrom-Json;if($i.manifest_sha256-cne$p.manifest_sha256){throw 'Original native intent'};Safe (Join-Path $case 'result.json') $false;Get-Content -LiteralPath (Join-Path $case 'result.json') -Raw;exit 0}
if(Test-Path -LiteralPath $case){throw 'Existing unit case: readback only'};New-Item -ItemType Directory -Path $case|Out-Null;Safe $case $true;WriteNew (Join-Path $case 'intent.json') $p
function Run($exe,$arguments){$s=New-Object Diagnostics.ProcessStartInfo;$s.FileName=$exe;$s.Arguments=$arguments;$s.UseShellExecute=$false;$s.CreateNoWindow=$true;$s.RedirectStandardOutput=$true;$s.RedirectStandardError=$true;$c=New-Object Diagnostics.Process;$c.StartInfo=$s;if(!$c.Start()){throw 'Unit process start'};try{$o=$c.StandardOutput.ReadToEndAsync();$e=$c.StandardError.ReadToEndAsync();$timed=$false;if(!$c.WaitForExit(30000)){$timed=$true;$c.Kill();$c.WaitForExit()};if($o.Result.Length-gt65536-or$e.Result.Length-gt65536){throw 'Unit output bound'};return @{exit_code=$c.ExitCode;timed_out=$timed;stdout=$o.Result;stderr=$e.Result}}finally{$c.Dispose()}}
WriteNew (Join-Path $case 'started.json') @{start_once=$true};$reports=@{}
foreach($kind in @('lib','bin')){$a=$p.artifacts.$kind;if($a.sha256-notmatch'^[a-f0-9]{64}$'-or$a.name-cne('windows-tests-'+$kind+'.exe')){throw 'Fixed unit artifact'};$folder=Join-Path $root $a.sha256;Safe $folder $true;$exe=Join-Path $folder $a.name;Safe $exe $false;if((Get-FileHash -LiteralPath $exe -Algorithm SHA256).Hash.ToLowerInvariant()-cne$a.sha256){throw 'Exact native unit hash'};$listed=Run $exe '--list --format terse';$names=@($listed.stdout-split'\r?\n'|Where-Object{$_-match': test$'}|ForEach-Object{$_-replace': test$',''}|Sort-Object);if($listed.exit_code-ne0-or$listed.timed_out-or$names.Count-ne$p.counts.$kind){throw 'Exact native count before tests'};$result=Run $exe '--test-threads=1';$v=@{sha256=$a.sha256;names=$names;listed=$listed;result=$result};WriteNew (Join-Path $case ($kind+'-result.json')) $v;$reports[$kind]=$v}
$value=@{manifest_sha256=$p.manifest_sha256;reports=$reports;bootstrap_administrator_units=$true;local_service_proof=$false;rmm_jobs=$false;product_state_writes=$false};WriteNew (Join-Path $case 'result.json') $value;$value|ConvertTo-Json -Depth 12 -Compress
'''
def verified(path, current=True):
value = cb.contract.protected_json(path)
require(value['type'] == 'rmm.windows.system-delegation-build' and value['schema_version'] == 1
and value['source_before_after_equal'] is True and value['production_clock_qualified'] is False
and value['default_and_feature_alltarget_clippy'] is True and value['native_counts_expected'] == COUNTS,
'exact delegation build profile')
if current:
require(value['source_files'] == sources() and value['core_native_proofs'] == core_proof(), 'source/native core binding')
require(set(value['artifacts']) == set(NAMES), 'all deployable/test artifacts')
for kind, item in value['artifacts'].items():
binary, linked = Path(item['path']), Path(item['original_link_path'])
require(item['name'] == NAMES[kind] and binary == path.resolve().parent / NAMES[kind]
and linked == path.resolve().parent / (NAMES[kind] + '.linked'), 'fixed artifact paths and names')
for file in (binary, linked):
info = file.lstat()
require(not file.is_symlink() and stat.S_ISREG(info.st_mode) and info.st_uid == os.getuid()
and stat.S_IMODE(info.st_mode) == 0o600, 'private regular retained artifact')
require(binary.resolve().parent == path.resolve().parent
and linked.resolve().parent == path.resolve().parent
and sha(item['path']) == item['sha256']
and sha(item['original_link_path']) == item['original_link_sha256'], 'retained exact artifact/link')
return value
def native(path, ident=None):
manifest = verified(path, current=ident is None)
if ident is None:
ident = str(uuid.uuid4())
folder = STATE / ident
folder.mkdir(mode=0o700)
save(folder / 'intent.json', {'id': ident, 'manifest_path': str(path.resolve()), 'manifest_sha256': sha(path),
'runner_sha256': sha(__file__), 'script_sha256': hashlib.sha256(SCRIPT.encode()).hexdigest()})
save(folder / 'server-before.json', {'counts': auto.scopes(), 'flags': auto.status()})
for kind in COUNTS:
previous.upload(manifest['artifacts'][kind])
save(folder / 'started-local.json', {'start_once': True})
action = 'run'
else:
ident = str(uuid.UUID(ident))
folder = STATE / ident
intent = cb.contract.protected_json(folder / 'intent.json')
require(intent['manifest_sha256'] == sha(path) and intent['manifest_path'] == str(path.resolve())
and intent['runner_sha256'] == sha(__file__)
and intent['script_sha256'] == hashlib.sha256(SCRIPT.encode()).hexdigest()
and (folder / 'started-local.json').exists(), 'same exact started case; readback only')
action = 'read'
result = cb.powershell(SCRIPT, {'id': ident, 'action': action, 'manifest_sha256': sha(path),
'artifacts': {k: manifest['artifacts'][k] for k in COUNTS}, 'counts': COUNTS}, timeout=100)
save(folder / ('readback-' + str(uuid.uuid4()) + '.json'), result)
require(result['manifest_sha256'] == sha(path) and set(result['reports']) == set(COUNTS), 'exact native manifest/reports')
for kind, actual in result['reports'].items():
run = actual['result']
listed = actual['listed']
require(actual['sha256'] == manifest['artifacts'][kind]['sha256'] and len(actual['names']) == COUNTS[kind]
and listed['exit_code'] == run['exit_code'] == 0 and not listed['timed_out'] and not run['timed_out']
and len(set(actual['names'])) == COUNTS[kind]
and re.search(r'test result: ok\. ' + str(COUNTS[kind])
+ r' passed; 0 failed; 0 ignored; 0 measured; 0 filtered out;', run['stdout']),
'every native unit passes, none skipped/filtered')
before = cb.contract.protected_json(folder / 'server-before.json')
require(auto.scopes() == before['counts'] and auto.status() == before['flags'] and auto.flags_disabled(before['flags']),
'both target counts and closed policies unchanged')
proof = {'verified': True, 'case_id': ident, 'manifest_path': str(path.resolve()), 'manifest_sha256': sha(path),
'native': result, 'no_jobs': True, 'clock_adapter_qualified': False, 'local_service_proof': False}
destination = folder / 'passed.json'
if destination.exists():
require(cb.contract.protected_json(destination) == proof, 'retain exact original native proof')
else:
save(destination, proof)
print(json.dumps({'verified': True, 'case_id': ident, 'tests': COUNTS, 'proof': str(destination.resolve())}))
def main():
os.umask(0o077)
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('phase', choices=('build-local', 'native-units', 'readback'))
parser.add_argument('--manifest', type=Path)
parser.add_argument('--case')
args = parser.parse_args()
if args.phase == 'build-local':
require(not (args.manifest or args.case), 'local build only')
build()
else:
require(args.manifest and ((args.phase == 'readback') == bool(args.case)), 'explicit manifest and original readback case')
native(args.manifest, args.case)
if __name__ == '__main__':
try:
main()
except Exception as error:
print('WINDOWS_DELEGATION_QUALIFICATION_INCOMPLETE:' + type(error).__name__)
raise SystemExit(2) from None