Files
rust-discovery/deploy/shared_core_acceptance.py
2026-11-14 02:01:17 +01:00

276 lines
18 KiB
Python

#!/usr/bin/env python3
"""Fixed native shared-core unit qualification: Linux FIRST, then Windows.
No RMM jobs, enrollment, runtime replacement, daemon changes or server contact.
A lost execution reply permits readback only, never an automatic test rerun.
"""
import argparse
import base64
import contextlib
import hashlib
import io
import json
import os
from pathlib import Path
import re
import stat
import subprocess
import uuid
import remote_client_bootstrap as linux
import vm_mvp_acceptance as contract
from windows import client_bootstrap as windows
ROOT = Path(__file__).resolve().parents[1]
STATE = ROOT / 'devstate/shared-core/acceptance'
PROFILES = {
'original': {'linux': {'contracts':5, 'reconcile':20}, 'windows': {'contracts':4, 'reconcile':20}},
'helper-sync-v1': {'linux': {'contracts':5, 'reconcile':21, 'helper-reconcile':22, 'linux-helper':21}, 'windows': {'contracts':4, 'reconcile':21, 'helper-reconcile':22}},
'durable-outcome-v1': {'linux': {'contracts':7, 'reconcile':26, 'helper-reconcile':22, 'linux-helper':21}, 'windows': {'contracts':6, 'reconcile':26, 'helper-reconcile':22}},
}
KINDS = ('contracts', 'reconcile') # Historical original qualification only.
REMOTE_LINUX = '/var/lib/rmm-shared-core-acceptance'
def sha(data):
return hashlib.sha256(data).hexdigest()
def write_new(path, value):
path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
contract.write_private(path, value)
def source_paths(profile):
contract.require(profile in PROFILES, 'fixed qualification profile')
sources = [ROOT/'Cargo.toml', ROOT/'Cargo.lock', ROOT/'rust-toolchain.toml']
crates = ['agent-core', 'domain', 'protocol']
if profile in ('helper-sync-v1','durable-outcome-v1'): crates.extend(('agent', 'agent-linux', 'privileged-helper'))
for name in crates:
sources.extend(p for p in (ROOT/'crates'/name).rglob('*') if p.is_file() and (p.suffix == '.rs' or p.name == 'Cargo.toml'))
sources.extend((ROOT/'proto').glob('*.proto'))
if profile in ('helper-sync-v1','durable-outcome-v1'):
sources.extend(ROOT/p for p in ('tools/apt-transaction/apt_transaction.py', 'tools/apt-transaction/hook', 'deploy/linux/rmm-apt-helper.service', 'tests/apt_transaction/fixtures/planning-canonical.json'))
return sources
def qualified(platform, profile='original'):
folder = ROOT/'devstate'/('shared-core' if platform == 'linux' else 'windows-core')
if profile != 'original': folder = folder/profile
manifest = contract.protected_json(folder/'manifest.json')
contract.require(manifest.get('qualification_profile', 'original') == profile, 'bound qualification profile')
actual = {str(p.relative_to(ROOT)): sha(p.read_bytes()) for p in source_paths(profile)}
contract.require(manifest['source_files'] == actual and manifest['source_before_after_equal'] is True, 'qualified source bindings changed')
target = 'x86_64-unknown-linux-gnu' if platform == 'linux' else 'x86_64-pc-windows-gnu'
contract.require(manifest['schema_version'] == 1 and manifest['target'] == target and manifest['os_effects'] is False and manifest['native_vm_executed'] is False, 'fixed test-only qualification')
contract.require(all(manifest['checks'][n] is True for n in ('rustfmt_check', 'linux_all_target_clippy_warnings_denied', 'windows_all_target_clippy_warnings_denied')), 'qualified checks')
artifacts = {}
for kind, item in zip(PROFILES[profile][platform], manifest['artifacts'], strict=True):
path = folder/(kind + ('.exe' if platform == 'windows' else ''))
contract.require(item['path'] == str(path.relative_to(ROOT)) and not path.is_symlink() and path.is_file(), 'fixed artifact path')
contract.require(stat.S_IMODE(path.stat().st_mode) == 0o600 and path.stat().st_uid == os.getuid(), 'private artifact owner/mode')
contract.require(item['binary_sha256'] == sha(path.read_bytes()) and item['size_bytes'] == path.stat().st_size, 'artifact hash/size')
contract.require(item['test_count'] == PROFILES[profile][platform][kind], 'fixed test count')
artifacts[kind] = item
return dict(manifest_sha256=sha((folder/'manifest.json').read_bytes()), artifacts=artifacts)
# Functions sent by the existing pinned SSH/bootstrap RPC. Only fixed test files
# are touched, never production journals, keys, packages, services or endpoints.
def linux_case(payload):
import stat
root = Path('/var/lib/rmm-shared-core-acceptance')
ident = str(uuid.UUID(payload['id']))
require(ident == payload['id'] and payload['action'] in ('prepare', 'run', 'read'), 'fixed case')
entries = payload['artifacts']
profile=payload.get('profile','original')
profiles={'original':{'contracts':5,'reconcile':20},'helper-sync-v1':{'contracts':5,'reconcile':21,'helper-reconcile':22,'linux-helper':21},'durable-outcome-v1':{'contracts':7,'reconcile':26,'helper-reconcile':22,'linux-helper':21}}
require(profile in profiles and set(entries)==set(profiles[profile]), 'fixed qualification artifacts')
for kind, item in entries.items():
require(len(item['binary_sha256']) == 64 and all(c in '0123456789abcdef' for c in item['binary_sha256']), 'fixed hash')
require(item['test_count'] == profiles[profile][kind], 'fixed test count')
require(os.geteuid() == 0, 'bootstrap root only')
def safe(path, directory):
m = path.lstat()
require(not stat.S_ISLNK(m.st_mode) and m.st_uid == 0 and not m.st_mode & 0o022 and (stat.S_ISDIR(m.st_mode) if directory else stat.S_ISREG(m.st_mode)), 'private fixed test path')
def save(path, value):
fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, 0o600)
with os.fdopen(fd, 'w') as out:
json.dump(value, out); out.flush(); os.fsync(out.fileno())
if not root.exists(): root.mkdir(mode=0o700)
safe(root, True)
case = root/ident
if payload['action'] == 'prepare':
case.mkdir(mode=0o700)
save(case/'intent.json', dict(id=ident, profile=profile, artifacts=entries, linux_manifest_sha256=payload['linux_manifest_sha256'], windows_manifest_sha256=payload['windows_manifest_sha256'], test_only=True))
for item in entries.values(): (case/item['binary_sha256']).mkdir(mode=0o700)
return dict(prepared=True)
safe(case, True); safe(case/'intent.json', False)
intent = json.loads((case/'intent.json').read_bytes())
require(intent.get('profile','original') == profile and intent['artifacts'] == entries and intent['linux_manifest_sha256'] == payload['linux_manifest_sha256'] and intent['windows_manifest_sha256'] == payload['windows_manifest_sha256'], 'same native intent')
kind = payload['kind']; require(kind in profiles[profile], 'fixed test kind')
result_path = case/(kind+'-result.json')
if payload['action'] == 'read':
safe(result_path, False)
return json.loads(result_path.read_bytes())
save(case/(kind+'-started.json'), dict(kind=kind, binary_sha256=entries[kind]['binary_sha256']))
path = case/entries[kind]['binary_sha256']/kind
safe(path.parent, True); safe(path, False)
require(hashlib.sha256(path.read_bytes()).hexdigest() == entries[kind]['binary_sha256'], 'pinned test hash')
path.chmod(0o500)
outputs = []
for label in ('stdout', 'stderr'):
outputs.append(open(case/(kind+'-'+label+'.bin'), 'xb'))
os.chmod(outputs[-1].name, 0o600)
timed_out = False
try:
try:
result = subprocess.run([str(path), '--test-threads=1'], stdin=subprocess.DEVNULL, stdout=outputs[0], stderr=outputs[1], timeout=25)
code = result.returncode
except subprocess.TimeoutExpired:
timed_out = True; code = None
finally:
for out in outputs: out.flush(); os.fsync(out.fileno()); out.close()
raw = [(case/(kind+'-'+label+'.bin')).read_bytes() for label in ('stdout', 'stderr')]
require(all(len(b) <= 1024*1024 for b in raw), 'fixed unit output bound')
report = dict(kind=kind, binary_sha256=entries[kind]['binary_sha256'], exit_code=code, timed_out=timed_out, stdout_b64=base64.b64encode(raw[0]).decode(), stderr_b64=base64.b64encode(raw[1]).decode(), native_platform='linux')
save(result_path, report)
return report
WINDOWS = r'''
$ErrorActionPreference='Stop'
$p=([Console]::In.ReadLine() | ConvertFrom-Json)
if (!$p.profile) {$p | Add-Member -NotePropertyName profile -NotePropertyValue 'original'}
$kinds=@('contracts','reconcile');if ($p.profile -in @('helper-sync-v1','durable-outcome-v1')) {$kinds+=@('helper-reconcile')}
if ($p.profile -notin @('original','helper-sync-v1','durable-outcome-v1')) {throw 'Fixed qualification profile'}
if ([string]([guid]$p.id) -cne $p.id -or $p.kind -notin $kinds -or $p.action -notin @('run','read') -or $p.sha256 -notmatch '^[0-9a-f]{64}$' -or $p.linux_evidence_sha256 -notmatch '^[0-9a-f]{64}$') {throw 'Fixed native core case'}
$root='C:\ProgramData\RustDiscoveryBootstrap'
$case=Join-Path $root ('shared-core-'+$p.id)
function Safe([string]$path,[bool]$directory) {
$i=Get-Item -LiteralPath $path -Force
if ($i.PSIsContainer -ne $directory -or ($i.Attributes -band [IO.FileAttributes]::ReparsePoint)) {throw 'Fixed test path type'}
$a=Get-Acl -LiteralPath $path
if ($a.GetOwner([Security.Principal.SecurityIdentifier]).Value -notin @('S-1-5-18','S-1-5-32-544')) {throw 'Private test owner'}
$rules=@($a.GetAccessRules($true,$true,[Security.Principal.SecurityIdentifier]))
if (!$rules.Count) {throw 'Empty test DACL'}
foreach($r in $rules) {if ($r.AccessControlType -ne 'Allow' -or $r.IdentityReference.Value -notin @('S-1-5-18','S-1-5-32-544')) {throw 'Broad test DACL'}}
}
function Write-New([string]$path,$value) {
$b=[Text.Encoding]::UTF8.GetBytes(($value | ConvertTo-Json -Compress -Depth 8))
$f=[IO.File]::Open($path,[IO.FileMode]::CreateNew,[IO.FileAccess]::Write,[IO.FileShare]::Read)
try {$f.Write($b,0,$b.Length);$f.Flush($true)} finally {$f.Dispose()}
}
Safe $root $true
if (!(Test-Path -LiteralPath $case)) {
if ($p.action -ne 'run' -or $p.kind -ne 'contracts') {throw 'Native intent missing'}
New-Item -ItemType Directory -Path $case | Out-Null
Write-New (Join-Path $case 'intent.json') @{id=$p.id;profile=$p.profile;linux_evidence_sha256=$p.linux_evidence_sha256;test_only=$true}
}
Safe $case $true
$intent=Get-Content -LiteralPath (Join-Path $case 'intent.json') -Raw | ConvertFrom-Json
if ((!$intent.profile -and $p.profile -ne 'original') -or ($intent.profile -and $intent.profile -cne $p.profile) -or $intent.id -cne $p.id -or $intent.linux_evidence_sha256 -cne $p.linux_evidence_sha256) {throw 'Bound Linux-first evidence'}
$result=Join-Path $case ($p.kind+'-result.json')
if ($p.action -eq 'read') {Safe $result $false;Get-Content -LiteralPath $result -Raw;exit 0}
Write-New (Join-Path $case ($p.kind+'-started.json')) @{kind=$p.kind;sha256=$p.sha256}
$folder=Join-Path $root $p.sha256;Safe $folder $true
$exe=Join-Path $folder ('windows-core-'+$p.kind+'.exe');Safe $exe $false
if ((Get-FileHash -LiteralPath $exe -Algorithm SHA256).Hash.ToLowerInvariant() -cne $p.sha256) {throw 'Pinned unit hash'}
$out=Join-Path $case ($p.kind+'-stdout.bin');$err=Join-Path $case ($p.kind+'-stderr.bin')
if ((Test-Path -LiteralPath $out) -or (Test-Path -LiteralPath $err)) {throw 'Existing native output'}
$proc=Start-Process -FilePath $exe -ArgumentList @('--test-threads=1') -PassThru -WindowStyle Hidden -RedirectStandardOutput $out -RedirectStandardError $err
$handle=$proc.Handle;$timeout=$false
if (!$proc.WaitForExit(25000)) {$timeout=$true;$proc.Kill();$proc.WaitForExit()}
$proc.Refresh();$code=$proc.ExitCode
if ((Get-Item -LiteralPath $out).Length -gt 1048576 -or (Get-Item -LiteralPath $err).Length -gt 1048576) {throw 'Fixed unit output bound'}
$value=@{kind=$p.kind;binary_sha256=$p.sha256;exit_code=$code;timed_out=$timeout;stdout_b64=[Convert]::ToBase64String([IO.File]::ReadAllBytes($out));stderr_b64=[Convert]::ToBase64String([IO.File]::ReadAllBytes($err));native_platform='windows'}
Write-New $result $value
$value | ConvertTo-Json -Compress -Depth 8
'''
def upload_linux(case, kind, item):
cfg = linux.access.load_config(ROOT/'credentials/linux-vm.conf')
args = ['sftp', '-F', '/dev/null', '-P', cfg.get('port', '22'), '-o', 'StrictHostKeyChecking=yes', '-o', 'BatchMode=yes', '-o', 'IdentitiesOnly=yes', '-o', 'ForwardAgent=no', '-o', 'ConnectTimeout=10', '-i', str(Path(cfg['ssh_key_path']).expanduser()), '-b', '-', cfg['username']+'@'+cfg['address']]
path = ROOT/item['path']
remote = REMOTE_LINUX+'/'+case.name+'/'+item['binary_sha256']+'/'+kind
batch = 'put '+json.dumps(str(path))+' '+json.dumps(remote)+'\n'
result = subprocess.run(args, input=batch.encode(), capture_output=True, timeout=120)
write_new(case/('linux-'+kind+'-sftp.json'), dict(returncode=result.returncode, stdout_b64=base64.b64encode(result.stdout).decode(), stderr_b64=base64.b64encode(result.stderr).decode()))
contract.require(result.returncode == 0, 'private Linux SFTP failure; inspect case')
def payload(intent, action, kind=None):
return dict(id=intent['id'], profile=intent.get('profile','original'), action=action, kind=kind, artifacts=intent['linux']['artifacts'], linux_manifest_sha256=intent['linux']['manifest_sha256'], windows_manifest_sha256=intent['windows']['manifest_sha256'])
def verify_result(platform, kind, result, expected):
contract.require(result['native_platform'] == platform and result['kind'] == kind and result['binary_sha256'] == expected['binary_sha256'] and result['exit_code'] == 0 and result['timed_out'] is False, 'native test exit/hash')
out = base64.b64decode(result['stdout_b64'], validate=True)
err = base64.b64decode(result['stderr_b64'], validate=True)
contract.require(len(out) <= 1024*1024 and len(err) <= 1024*1024, 'private unit output limit')
pattern = rb'test result: ok\. '+str(expected['test_count']).encode()+rb' passed; 0 failed; 0 ignored; 0 measured; 0 filtered out;'
contract.require(re.search(pattern, out) is not None, 'exact native unit counts, no skipped cases')
def main():
os.umask(0o077)
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('action', choices=('linux', 'windows', 'finish-linux', 'finish-windows'))
parser.add_argument('--case-id')
parser.add_argument('--profile', choices=tuple(PROFILES), default='original')
args = parser.parse_args()
if args.action == 'linux':
contract.require(args.case_id is None, 'new Linux case chooses fresh UUID')
ident = str(uuid.uuid4()); case = STATE/ident
intent = dict(id=ident, linux=qualified('linux',args.profile), windows=qualified('windows',args.profile))
if args.profile != 'original': intent['profile']=args.profile
write_new(case/'intent.json', intent)
else:
contract.require(args.case_id is not None and str(uuid.UUID(args.case_id)) == args.case_id, 'fixed existing case UUID')
case = STATE/args.case_id
intent = contract.protected_json(case/'intent.json')
contract.require(intent['id'] == args.case_id and intent.get('profile','original')==args.profile and intent['linux'] == qualified('linux',args.profile) and intent['windows'] == qualified('windows',args.profile), 'same qualified case source/artifacts')
platform = 'linux' if args.action.endswith('linux') else 'windows'
if platform == 'windows':
proof = contract.protected_json(case/'linux-passed.json')
contract.require(proof['id'] == intent['id'] and proof['passed'] is True and proof['qualification'] == intent['linux'], 'Linux-first native qualification required')
for kind in PROFILES[args.profile]['linux']: verify_result('linux', kind, proof['results'][kind], intent['linux']['artifacts'][kind])
linux_sha = sha((case/'linux-passed.json').read_bytes())
else: linux_sha = None
finish = args.action.startswith('finish-')
if not finish:
write_new(case/(platform+'-started.json'), dict(id=intent['id'], profile=args.profile, linux_evidence_sha256=linux_sha))
if args.action == 'linux':
linux.rpc('linux-vm.conf', linux_case, payload(intent, 'prepare'))
for kind in PROFILES[args.profile]['linux']: upload_linux(case, kind, intent['linux']['artifacts'][kind])
results = {}
for kind in PROFILES[args.profile][platform]:
if platform == 'linux':
result = linux.rpc('linux-vm.conf', linux_case, payload(intent, 'read' if finish else 'run', kind))
else:
item = intent['windows']['artifacts'][kind]
# Existing bootstrap prints only sanitized failures; keep even these
# in the protected case so this CLI never prints remote diagnostics.
captured = io.StringIO()
try:
with contextlib.redirect_stdout(captured):
if not finish: windows.upload(ROOT/item['path'], 'windows-core-'+kind+'.exe')
result = windows.powershell(WINDOWS, dict(id=intent['id'], profile=args.profile, kind=kind, action='read' if finish else 'run', sha256=item['binary_sha256'], linux_evidence_sha256=linux_sha), timeout=40)
finally:
write_new(case/('windows-'+kind+'-transport-'+uuid.uuid4().hex+'.json'), dict(sanitized_bootstrap_output=captured.getvalue()))
write_new(case/(platform+'-'+kind+'-readback-'+uuid.uuid4().hex+'.json'), result)
verify_result(platform, kind, result, intent[platform]['artifacts'][kind]); results[kind] = result
proof = dict(id=intent['id'], passed=True, native_platform=platform, qualification=intent[platform], linux_evidence_sha256=linux_sha, results=results)
destination = case/(platform+'-passed.json')
if destination.exists(): contract.require(contract.protected_json(destination) == proof, 'identical original native proof')
else: write_new(destination, proof)
print(json.dumps(dict(result='PASS', native_platform=platform, case_id=intent['id'], evidence_sha256=sha(destination.read_bytes()), artifact_sha256={k:v['binary_sha256'] for k,v in intent[platform]['artifacts'].items()})))
if __name__ == '__main__':
try: main()
except Exception as error:
print('SHARED_CORE_ACCEPTANCE_INCOMPLETE:'+type(error).__name__)
raise SystemExit(2) from None