Files
rust-discovery/deploy/cloud_mvp_acceptance.py

270 lines
17 KiB
Python

#!/usr/bin/env python3
"""Cloud-only MCP → pending → actual dev/test WebUI → VM result acceptance.
No local executor/server, enrollment, direct approval API/SQL or retry exists.
Credentials stay on the cloud server; the browser reads its protected login
file. All SQL is fixed read-only evidence, scoped to the one cloud VM.
"""
import argparse
from datetime import timedelta
import hashlib
import http.client
import json
import os
from pathlib import Path
import shutil
import subprocess
import socket
import ssl
import time
import uuid
import remote_client_bootstrap as bootstrap
import vm_mvp_acceptance as contract
ROOT = bootstrap.ROOT
TENANT = bootstrap.TENANT
require = bootstrap.require
WINDOWS_AGENT = '63ea15b2-0643-403d-b5b4-cba1288dbea3'
WINDOWS_ASSET = 'a176520e-8a91-4e93-a78b-8e7620f430e0'
WINDOWS_SCRIPT = "Write-Output 'Zeitprofil-Test'\r\n"
WINDOWS_STDOUT = 'Zeitprofil-Test\r\n'
def windows_hello_input():
start = contract.now()
return dict(
tenant_id=TENANT, action='run_script', targets=dict(asset_ids=[WINDOWS_ASSET]),
parameters=dict(
execution_identity='agent_service', timeout_seconds=60, max_output_bytes=65536,
arguments=[], expected_stdout=WINDOWS_STDOUT,
variants=[dict(os_family='windows', interpreter='powershell', encoding='utf-8',
script_utf8=WINDOWS_SCRIPT, windows_execution_profile='powershell_51_remote_signed')]),
schedule=contract.schedule(start, start + timedelta(minutes=15)),
rollout=dict(max_parallel=1, halt_after_failures=1),
reason='Erste genehmigte PowerShell-Textausgabe auf der Windows-Test-VM')
def verify_windows_hello(result):
report = result['result']
proof = report['evidence']
contract.require(result['state'] == 'succeeded' and report['exit_code'] == 0
and bytes(report['stdout']) == WINDOWS_STDOUT.encode() and bytes(report['stderr']) == b''
and report['output_truncated'] is False and proof['postconditions_passed'] is True
and proof['execution_sid'] == 'S-1-5-19' and proof['interpreter'] == 'powershell'
and proof['script_sha256'] == hashlib.sha256(WINDOWS_SCRIPT.encode()).hexdigest()
and proof['windows_execution_profile'] == 'powershell_51_remote_signed'
and proof['execution_policy'] == 'process_remote_signed_requested'
and proof['execution_policy_requested'] == 'RemoteSigned'
and proof['execution_policy_scope'] == 'process', 'windows_hello_evidence')
def prepare_browser():
cache=ROOT/'web/node_modules/.cache/cloud-acceptance'
nss=cache/'home/.pki/nssdb';nss.mkdir(mode=0o700,parents=True,exist_ok=True)
for directory in (cache,cache/'home',cache/'home/.pki',nss):directory.chmod(0o700)
ca=ROOT/'credentials/server-ca.pem';ssl.create_default_context(cafile=str(ca))
tool=shutil.which('certutil') or str(ROOT/'web/node_modules/.cache/nss-tools/root/usr/bin/certutil')
commands=[]
if not (nss/'cert9.db').exists():commands.append([tool,'-N','-d','sql:'+str(nss),'--empty-password'])
commands.extend(([tool,'-A','-d','sql:'+str(nss),'-n','RMM cloud acceptance CA','-t','C,,','-i',str(ca)],
[tool,'-V','-d','sql:'+str(nss),'-n','RMM cloud acceptance CA','-u','L']))
for cmd in commands:
contract.require(subprocess.run(cmd,capture_output=True,timeout=15).returncode==0,'isolated_browser_trust_unavailable')
def vm_transport(payload):
import sqlite3
mode=payload['mode'];require(mode in ('wss','https'),'transport_allowlist')
state=Path('/var/lib/rmm-agent-remote')
identity=json.loads((state/'identity.json').read_text())
require(identity['agent_id']==payload['agent_id'],'fixed_cloud_vm_identity')
binary=Path('/usr/local/libexec/rmm-agent-remote')
require(hashlib.sha256(binary.read_bytes()).hexdigest()==payload['binary_sha256'],'fixed_artifact')
with sqlite3.connect('file:'+str(state/'journal.sqlite')+'?mode=ro',uri=True) as db:
require(db.execute("SELECT count(*) FROM job_attempts WHERE state NOT IN ('succeeded','failed','cancelled','expired')").fetchone()[0]==0,'unresolved_native_job')
require('RMM_TRANSPORT=' not in Path('/etc/rmm-remote/agent.env').read_text(),'environment_override_conflict')
directory=Path('/etc/systemd/system/rmm-agent-remote.service.d')
require(not directory.is_symlink(),'unsafe_dropin_directory')
directory.mkdir(mode=0o755,exist_ok=True);directory.chmod(0o755)
require(directory.stat().st_uid==0 and directory.stat().st_mode&0o022==0,'unsafe_dropin_owner')
path=directory/'95-cloud-acceptance-transport.conf'
allowed=['[Service]\nEnvironment=RMM_TRANSPORT='+m+'\n' for m in ('wss','https')]
require(not path.is_symlink() and (not path.exists() or path.stat().st_uid==0 and path.read_text() in allowed),'unknown_transport_dropin')
if mode=='wss':
if path.exists():path.unlink()
else:
fd=os.open(path,os.O_WRONLY|os.O_CREAT|os.O_TRUNC|os.O_NOFOLLOW,0o644)
with os.fdopen(fd,'w') as stream:stream.write(allowed[1]);stream.flush();os.fsync(stream.fileno())
path.chmod(0o644)
subprocess.run(['systemctl','daemon-reload'],capture_output=True,check=True)
subprocess.run(['systemctl','restart','rmm-agent-remote.service'],capture_output=True,check=True)
return dict(requested=mode,only_cloud_vm=True)
def server(payload):
root = Path('/opt/rust-discovery')
if payload['kind'] == 'http':
require(payload['path'] in ('/mcp', '/auth/config'), 'no administrative mutation endpoint')
class HTTPS(http.client.HTTPSConnection):
def connect(self):
self.sock = self._context.wrap_socket(socket.create_connection(('127.0.0.1',18443),timeout=10), server_hostname=self.host)
client = HTTPS('localhost',18443,context=ssl.create_default_context(cafile=str(root/'devstate/pki/ca.pem')))
headers = {'Content-Type':'application/json', **payload.get('headers',{})}
require(not any(k.lower() in ('authorization','cookie','x-csrf-token') for k in headers), 'caller credential injection')
if payload['path'] == '/mcp':
principal=payload.get('principal','a'); require(principal in ('a','b'),'fixed_test_principal')
headers['Authorization'] = 'Bearer '+(root/('devstate/operator-'+principal+'.token')).read_text().strip()
client.request(payload['method'],payload['path'],body=json.dumps(payload['body']) if payload.get('body') is not None else None,headers=headers)
response = client.getresponse(); status = response.status; returned = dict(response.getheaders())
if 'text/event-stream' in response.getheader('Content-Type',''):
data = None
for _ in range(128):
line = response.readline(1024*1024)
if not line: break
if line.startswith(b'data: ') and line[6:].strip():
item = json.loads(line[6:])
if 'result' in item or 'error' in item: data=item; break
else:
raw=response.read(1024*1024); data=json.loads(raw) if raw else None
client.close()
return dict(status=status,headers=returned,data=data)
tenant = str(uuid.UUID(payload['tenant_id'])); agent = str(uuid.UUID(payload['agent_id']))
require(tenant == '11111111-1111-4111-8111-111111111111', 'fixed test tenant required')
scope = "tenant_id='"+tenant+"' AND agent_id='"+agent+"'"
if payload['kind'] == 'gate':
job = str(uuid.UUID(payload['job_id'])) if payload.get('job_id') else None
selected = scope + (" AND job_id='"+job+"'" if job else '')
query = ("SELECT json_build_object('jobs',(SELECT count(*) FROM jobs WHERE "+selected+"),"
"'outbox',(SELECT count(*) FROM outbox o JOIN jobs j USING(tenant_id,job_id,attempt_id) WHERE "+
selected.replace('tenant_id=', 'j.tenant_id=').replace('agent_id=', 'j.agent_id=').replace('job_id=', 'j.job_id=')+"),"
"'permits',(SELECT count(*) FROM execution_permits e JOIN jobs j USING(tenant_id,job_id,attempt_id) WHERE "+
selected.replace('tenant_id=', 'j.tenant_id=').replace('agent_id=', 'j.agent_id=').replace('job_id=', 'j.job_id=')+"),"
"'unresolved',(SELECT count(*) FROM jobs WHERE "+scope+" AND state NOT IN ('succeeded','failed','cancelled','expired','closed_unknown')));")
else:
require(payload['kind'] == 'audit', 'unknown evidence query')
operation = str(uuid.UUID(payload['operation_id']))
query = ("SELECT json_build_object('origin',approval_origin,'simulation',testsimulation,'principal',principal,'plan_hash',plan_hash) "
"FROM authorizations WHERE tenant_id='"+tenant+"' AND operation_id='"+operation+"' "
"AND EXISTS(SELECT 1 FROM jobs WHERE "+scope+" AND operation_id='"+operation+"');")
cmd=['docker','compose','--env-file',str(root/'devstate/.env'),'-f',str(root/'deploy/server.compose.yaml'),
'exec','-T','postgres','psql','-X','-qAt','-v','ON_ERROR_STOP=1','-U','postgres','-d','rmm']
result=subprocess.run(cmd,input=query.encode(),capture_output=True,check=True).stdout.strip()
return json.loads(result) if result else {}
class Backend:
def __init__(self,principal='a'):
contract.require(principal in ('a','b'),'fixed_test_principal')
self.principal=principal
self.sequence=1
self.headers={'Accept':'application/json, text/event-stream','MCP-Protocol-Version':'2025-11-25'}
response=self.request(dict(jsonrpc='2.0',id=1,method='initialize',params=dict(protocolVersion='2025-11-25',capabilities={},clientInfo=dict(name='cloud-vm-mvp',version='1'))))
contract.require(response['status']==200 and response['data']['result']['protocolVersion']=='2025-11-25','mcp_initialize')
session=next(v for k,v in response['headers'].items() if k.lower()=='mcp-session-id')
self.headers['Mcp-Session-Id']=session
contract.require(self.request(dict(jsonrpc='2.0',method='notifications/initialized'))['status']==202,'mcp_initialized')
def request(self,body):
return bootstrap.rpc('server.conf',server,dict(kind='http',path='/mcp',method='POST',headers=self.headers,body=body,principal=self.principal))
def call(self,name,args):
contract.require(name in ('tenants.list','inventory.get_device','logs.query','operations.plan','operations.submit','jobs.get','jobs.cancel'),'tool_allowlist')
self.sequence+=1
response=self.request(dict(jsonrpc='2.0',id=self.sequence,method='tools/call',params=dict(name=name,arguments=args)))
data=response.get('data',{}) or {}
contract.require(response['status']==200 and 'result' in data and not data['result'].get('isError'),'mcp_tool_failed')
return data['result']['structuredContent']
def main():
parser=argparse.ArgumentParser(description=__doc__)
parser.add_argument('--execute-dev-test-ui',action='store_true',required=True)
parser.add_argument('--case',choices=('hello','refresh_inventory','cancel_queued','windows_hello'),default='hello')
parser.add_argument('--transport',choices=('wss','https'))
args=parser.parse_args();os.umask(0o077)
contract.require(not (Path.home()/'.local/share/rust-discovery/remote-agent').exists(),'notebook_must_not_have_client')
windows = args.case == 'windows_hello'
if windows:
contract.require(args.transport is None, 'windows_keep_current_transport')
identity = dict(agent_id=WINDOWS_AGENT, asset_id=WINDOWS_ASSET)
else:
prepare_browser()
installed=contract.protected_json(ROOT/'devstate/remote-vm.json')
identity=installed['identity']
settings=dict(tenant_id=TENANT,**identity)
def evidence(kind,**extra):
return bootstrap.rpc('server.conf',server,dict(kind=kind,tenant_id=TENANT,agent_id=identity['agent_id'],**extra))
contract.require(evidence('gate')['unresolved']==0,'unresolved_job_no_new_attempt')
if args.transport:
bootstrap.rpc('linux-vm.conf',vm_transport,dict(mode=args.transport,agent_id=identity['agent_id'],binary_sha256=installed['binary_sha256']))
end=time.monotonic()+90
while True:
observed=bootstrap.rpc('server.conf',bootstrap.server,dict(action='observe',agent_id=identity['agent_id']))
if observed.get('transport')==args.transport and observed.get('sync_ready') and not observed.get('restore_blocked'):break
contract.require(time.monotonic()<end,'native_transport_sync_not_ready');time.sleep(2)
backend=Backend()
device=backend.call('inventory.get_device',dict(tenant_id=TENANT,asset_id=identity['asset_id']))
contract.require(device['agent_id']==identity['agent_id'] and device['presence']=='online'
and 0 <= (contract.now()-contract.timestamp(device['last_contact_at'])).total_seconds()<90,'fresh_cloud_vm_required')
observed=bootstrap.rpc('server.conf',bootstrap.server,dict(action='observe',agent_id=identity['agent_id']))
contract.require(observed['sync_ready'] and not observed['restore_blocked'],'signed_sync_gate_required')
needed={'refresh_inventory' if args.case=='refresh_inventory' else 'run_script','rmm.sync.v1'}
if windows:
needed.update(('windows.base/1', 'script.powershell/1', 'script.powershell.process_remote_signed/1'))
contract.require(needed<=set(device['capabilities']),'actual_vm_capability_required')
if windows:
prepare_browser()
request=windows_hello_input() if windows else contract.case_input(args.case,settings)
plan=backend.call('operations.plan',dict(tenant_id=TENANT,input=request))
contract.require(hashlib.sha256(bytes(plan['plan_payload_bytes'])).hexdigest()==plan['plan_hash'] and len(plan['jobs'])==1,'immutable_plan')
job=plan['jobs'][0]
if windows:
contract.require(job['payload']['agent_id']==WINDOWS_AGENT and job['payload']['asset_id']==WINDOWS_ASSET
and job['payload']['tenant_id']==TENANT, 'fixed_windows_target_required')
folder=ROOT/'devstate/cloud-acceptance'/uuid.uuid4().hex;folder.mkdir(mode=0o700,parents=True)
checkpoint=dict(profile='dev/test',case=args.case,expected_principal='simulated-testprincipal-a',**settings,
plan=plan,job=job,stage='planned',no_retry=True,transport=observed['transport'],server_connection=observed)
path=folder/'checkpoint.json'
def save():
path.write_text(json.dumps(checkpoint,indent=2));path.chmod(0o600)
save()
pending=backend.call('operations.submit',dict(tenant_id=TENANT,plan_id=plan['plan_id'],idempotency_key='cloud-'+folder.name))
gate=evidence('gate',job_id=job['job_id'])
contract.require(pending['approval_state']=='pending_approval' and pending['job_count']==0 and pending['execution_state'] is None
and all(gate[k]==0 for k in ('jobs','outbox','permits')),'pending_has_zero_execution_artifacts')
checkpoint.update(operation_id=pending['operation_id'],preapproval=gate,stage='pending_approval');save()
process=subprocess.run(['node',str(ROOT/'deploy/browser/cloud_approve.cjs'),str(path)],capture_output=True,timeout=120)
contract.require(process.returncode==0,'browser_incomplete_preserve_checkpoint_never_retry')
if args.case=='cancel_queued':
backend.call('jobs.cancel',dict(tenant_id=TENANT,job_id=job['job_id'],reason='Explicit cloud dev/test cancellation before fixed future start'))
deadline=time.monotonic()+105
while True:
result=backend.call('jobs.get',dict(tenant_id=TENANT,job_id=job['job_id']))
if result['state'] in contract.TERMINAL or result['state'] in ('unknown','awaiting_reboot'):break
contract.require(time.monotonic()<deadline,'result_timeout_no_retry');time.sleep(2)
checkpoint.update(result=result,stage=result['state']);save()
if args.case=='cancel_queued':
contract.require(result['state']=='cancelled','confirmed_cancellation_required')
else:
contract.require(result['state']=='succeeded' and result['result']['evidence']['postconditions_passed'],'native_postconditions_required')
if args.case=='hello':
contract.require(result['result']['exit_code']==0 and bytes(result['result']['stdout'])==b'Hello World\n','exact_stdout_required')
elif windows:
verify_windows_hello(result)
elif args.case=='refresh_inventory':
contract.require(contract.timestamp(result['result']['evidence']['observed_at'])>=contract.timestamp(request['schedule']['not_before']),'fresh_inventory_required')
gate=evidence('gate',job_id=job['job_id']);audit=evidence('audit',operation_id=pending['operation_id'])
expected_counts=[1,1,0] if args.case=='cancel_queued' else [1,1,1]
contract.require([gate[k] for k in ('jobs','outbox','permits')]==expected_counts,'exact_job_outbox_grant_counts')
contract.require(audit==dict(origin='dev_test_browser_simulation',simulation=True,principal=checkpoint['expected_principal'],plan_hash=plan['plan_hash']),'interactive_simulation_audit')
checkpoint.update(verified=True,postapproval=gate,audit=audit);save()
print('PASS cloud VM '+args.case+': MCP pending 0/0/0, actual simulated UI approval, verified counts '+str(expected_counts))
if __name__=='__main__':
try:main()
except Exception as error:
print('CLOUD_ACCEPTANCE_INCOMPLETE:'+ (str(error) if isinstance(error,contract.GuardError) else type(error).__name__))
raise SystemExit(2) from None