Files
rust-discovery/tests/vm_mvp_guards.py
T

350 lines
24 KiB
Python

#!/usr/bin/env python3
"""Pure acceptance-harness guards; no VM, credentials, API mutations or approval."""
import ast
import copy
import datetime as dt
import hashlib
import json
import os
from pathlib import Path
import ssl
import sys
import tempfile
import unittest
from unittest.mock import patch
from types import SimpleNamespace
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'deploy'))
import vm_mvp_acceptance as m
import vm_mvp_adapters as advanced
import vm_mvp_runtime as native
import vm_runtime_upgrade as upgrade
class Guards(unittest.TestCase):
def settings(self):
return m.config(dict(profile='dev/test', origin=m.ORIGIN, connect_address='127.0.0.1:18443', ca_file=str(m.CA),
tenant_id='11111111-1111-4111-8111-111111111111', asset_id='22222222-2222-4222-8222-222222222222',
agent_id='33333333-3333-4333-8333-333333333333', agent_uid=993))
def artifact(self):
return dict(profile='dev/test', **{k:v for k,v in self.settings().items() if k in ('tenant_id','asset_id','agent_id')},
approved_cases=['hello'], expires_at=(m.now()+dt.timedelta(minutes=5)).isoformat(),
permission_origin='explicit_chat_user_permission',chat_date='2026-11-12',testsimulation=True,
expected_principal='simulated-testprincipal-a')
def test_only_exact_loopback_tls_origin_and_nonroot_network_identity(self):
for field, value in [('profile','production'), ('origin','https://127.0.0.1:18443'),
('origin','https://user:secret@rmm-dev.internal:18443'),
('connect_address','0.0.0.0:18443'), ('ca_file','/not/trusted.pem'), ('agent_uid',0)]:
with self.assertRaises(m.GuardError): m.config(dict(self.settings(), **{field:value}))
def test_protected_files_duplicate_fields_modes_and_symlinks(self):
with tempfile.TemporaryDirectory() as folder:
path=Path(folder)/'input.json'; path.write_text('{"a":1,"a":2}'); path.chmod(0o600)
with self.assertRaises(m.GuardError): m.protected_json(path)
path.write_text('{}'); self.assertEqual(m.protected_json(path), {})
path.chmod(0o644)
with self.assertRaises(m.GuardError): m.protected_json(path)
link=Path(folder)/'link'; link.symlink_to(path)
with self.assertRaises(m.GuardError): m.protected_json(link)
def test_invalid_ca_cannot_establish_a_trust_context(self):
with tempfile.TemporaryDirectory() as folder:
path=Path(folder)/'invalid-ca.pem'; path.write_text('NOT A CERTIFICATE')
with self.assertRaises(ssl.SSLError): ssl.create_default_context(cafile=str(path))
def test_fixed_hello_bytes_identity_and_deadline(self):
case=m.case_input('hello',self.settings())
self.assertEqual(case['parameters']['variants'][0]['script_utf8'], "printf '%s\\n' 'Hello World'\n")
self.assertEqual(case['parameters']['expected_stdout'],'Hello World\n')
self.assertEqual(case['targets']['asset_ids'],[self.settings()['asset_id']])
self.assertEqual(case['parameters']['execution_identity'],'agent_service')
self.assertEqual(m.timestamp(case['schedule']['start_before'])-m.timestamp(case['schedule']['not_before']),dt.timedelta(minutes=15))
def test_bounded_logs_and_exact_service_unit_only(self):
logs=m.case_input('query_logs',self.settings())['parameters']
self.assertEqual(logs['unit'],'rmm-mvp-test.service');self.assertEqual(logs['max_lines'],50)
self.assertEqual(m.timestamp(logs['until'])-m.timestamp(logs['since']),dt.timedelta(minutes=5))
for name,state in [('service_start','running'),('service_stop','stopped')]:
case=m.case_input(name,self.settings())['parameters']
self.assertEqual((case['unit'],case['state'],case['execution_identity'],case['timeout_seconds']),
('rmm-mvp-test.service',state,'root',180))
setup=m.case_input('service_setup',self.settings())['parameters']
self.assertEqual(setup['execution_identity'],'root')
self.assertEqual(hashlib.sha256(setup['variants'][0]['script_utf8'].encode()).hexdigest(),
'3e299e84021beaa4cbdce6fa63eda193f6f123aba86368890fe20684c43e78ae')
# The browser independently pins the reviewed bytes at the UI boundary.
# Check that pin locally as well; do not wait for a live approval run to
# discover drift between the two acceptance paths.
browser=(m.ROOT/'tests/browser/mvp-actions.spec.ts').read_text()
self.assertIn("update(text(action.script_utf8)).digest('hex')).toBe('" +
hashlib.sha256(setup['variants'][0]['script_utf8'].encode()).hexdigest() + "')", browser)
artifact=dict(self.artifact(),approved_cases=['service_setup','service_start','service_stop'])
m.validate_run_artifact(artifact,self.settings(),['service_setup','service_start','service_stop'])
with self.assertRaises(m.GuardError):m.validate_run_artifact(artifact,self.settings(),['service_start','service_setup','service_stop'])
def test_expired_or_unbounded_schedules_rejected(self):
for start,end in [(m.now()-dt.timedelta(minutes=2),m.now()-dt.timedelta(minutes=1)),
(m.now(),m.now()+dt.timedelta(hours=2))]:
with self.assertRaises(m.GuardError):m.schedule(start,end)
def test_explicit_scoped_artifact_no_pending_adapter_can_be_opted_in(self):
m.validate_run_artifact(self.artifact(),self.settings(),['hello'])
for changes,cases in [(dict(testsimulation=False),['hello']), (dict(profile='production'),['hello']),
(dict(expected_principal='real-person'),['hello']), ({},[]), ({},['hello','hello']),
(dict(approved_cases=['reboot_last','hello']),['reboot_last','hello']),
(dict(expires_at=(m.now()-dt.timedelta(seconds=1)).isoformat()),['hello'])]:
with self.assertRaises(m.GuardError):m.validate_run_artifact(dict(self.artifact(),**changes),self.settings(),cases)
def test_outstanding_unknown_or_replay_does_not_create_new_attempt(self):
m.safe_states(['succeeded','failed'])
for state in ('queued','accepted','running','verifying','unknown','awaiting_reboot'):
with self.assertRaises(m.GuardError):m.safe_states([state])
self.assertEqual(len(m.EXECUTABLE),15)
for name in ('duplicate_offer','lost_result_ack'):
with self.assertRaises(m.GuardError):m.case_input(name,self.settings())
def manifest(self):
pin='74036ae81223deab3aae994fd2a2a695af408741777e1ce17dcb4e32f1235867'
transaction=dict(schema_version=1, recipe_id='rmm-apt-fixture-install-1.0',recipe_version='1',platform='ubuntu-24.04-amd64',
resolver_config_version='rmm-apt-local-v1',no_reboot=True,status_fingerprint='a'*64,baseline_sha256='b'*64,
packages=[dict(name='rmm-mvp-test',architecture='all',old_version=None,new_version='1.0',origin='rmm-test',sha256=pin,
size=20672,archive_path='/var/lib/rmm-apt-transaction/archives/'+pin+'.deb')])
raw=json.dumps(transaction,separators=(',',':')).encode()
return dict(type='rmm.apt.helper-action',schema_version=2,action='apt-native-acceptance',execution_profile='dev-test',
transaction_sha256=hashlib.sha256(raw).hexdigest(),resolved_apt_transaction=transaction,transaction_bytes=list(raw),
provider_sha256='c'*64,hook_sha256='d'*64,apt_config_sha256='e'*64,runtime_sha256='f'*64,test_result_id='fixture-only')
def test_complete_apt_fixture_format_is_not_execution_or_acceptance(self):
value=self.manifest();self.assertEqual(m.validate_apt_manifest(value)['packages'][0]['name'],'rmm-mvp-test')
for field,bad in [('schema_version',1),('transaction_bytes',[True]),('runtime_sha256','missing'),('extra','unsigned')]:
with self.assertRaises(m.GuardError):m.validate_apt_manifest(dict(value,**{field:bad}))
changed=copy.deepcopy(value);changed['resolved_apt_transaction']['no_reboot']=False
with self.assertRaises(m.GuardError):m.validate_apt_manifest(changed)
def test_reboot_same_boot_or_exit_code_is_not_success(self):
ids=[str(__import__('uuid').uuid4()) for _ in range(7)]
checkpoint=dict(zip(('tenant_id','agent_id','asset_id','operation_id','job_id','attempt_id','old_boot_id'),ids),plan_hash='a'*64)
job=dict(job_id=checkpoint['job_id'],attempt_id=checkpoint['attempt_id'],state='succeeded',result=dict(exit_code=0,evidence={}))
with self.assertRaises(m.GuardError):m.validate_reboot_checkpoint(checkpoint,checkpoint['old_boot_id'],job)
with self.assertRaises(m.GuardError):m.validate_reboot_checkpoint(checkpoint,str(__import__('uuid').uuid4()),job)
def test_no_direct_approval_or_database_mutation_in_harness(self):
source=Path(m.__file__).read_text();tree=ast.parse(source)
for call in ast.walk(tree):
if isinstance(call,ast.Call) and isinstance(call.func,ast.Attribute) and call.func.attr=='request':
self.assertIsInstance(call.args[0],ast.Constant)
self.assertIn(call.args[0].value,('/mcp','/auth/config'))
for value in ast.walk(tree):
if isinstance(value,ast.Constant) and isinstance(value.value,str):
self.assertFalse(value.value.upper().startswith(('INSERT INTO ','UPDATE ','DELETE FROM ','DROP TABLE ')))
browser=(m.ROOT/'tests/browser/mvp-actions.spec.ts').read_text()
self.assertNotRegex(browser,r'page\.request|request\.(post|put)\(|evaluate\(')
def test_readonly_preflight_calls_only_read_tools(self):
settings=self.settings()
class Fake:
def __init__(self):self.calls=[]
def request(self,path):return 200,{},dict(dev_login_enabled=True)
def outstanding_guard(self,settings):pass
def call(self,name,args):
self.calls.append(name)
if name=='tenants.list':return dict(items=[dict(tenant_id=settings['tenant_id'])])
if name=='inventory.list_devices':return dict(truncated=True)
return dict(agent_id=settings['agent_id'],asset_id=settings['asset_id'],presence='unreachable',capabilities=[])
fake=Fake();_,report=m.preflight(fake,settings)
self.assertEqual(fake.calls,['tenants.list','inventory.list_devices','inventory.get_device','monitoring.get_health'])
self.assertFalse(report['effects_performed'])
def planning(self,upgrade=False):
baseline={} if not upgrade else {'rmm-mvp-test:all':dict(version='1.0',status='install ok installed')}
runtime=dict(apt_config_sha256='e'*64)
return dict(fixture_package=baseline.get('rmm-mvp-test:all'),baseline=baseline,baseline_sha256=advanced.digest(advanced.canonical(baseline)),
sealed_baseline_sha256=advanced.digest(advanced.canonical(baseline)),status_records={},status_fingerprint=advanced.digest(b'{}'),
dpkg_updates_empty=True,pending_triggers_empty=True,host_reboot_required=False,runtime=runtime,runtime_sha256=advanced.digest(advanced.canonical(runtime)),
provider_sha256='c'*64,hook_sha256='d'*64,apt_config_sha256='e'*64,
prefetch={pin:dict(schema_version=1,sha256=pin,size=20672,sealed_at_ms=1) for pin in advanced.PINS.values()})
def test_all_four_apt_adapters_preserve_complete_typed_manifests(self):
for name in advanced.APT_CASES:
data=self.planning(name in ('apt_native_update','apply_updates','ensure_package'))
case=m.case_input(name,self.settings(),planning=data)
value=case['parameters']['apt_manifest'];m.validate_apt_manifest(value)
self.assertEqual(value['resolved_apt_transaction'],json.loads(bytes(value['transaction_bytes'])))
self.assertEqual(case['parameters']['execution_identity'],'root')
self.assertEqual(value['action'],'apt-native-acceptance' if name.startswith('apt_native_') else 'apt-execute')
self.assertEqual(case['parameters']['timeout_seconds'],300)
def test_no_live_ssh_planning_fallback_when_passive_data_missing_or_dirty(self):
with self.assertRaisesRegex(m.GuardError,'stored_linux.apt.planning'):advanced.planning_from_device(dict(inventory={}))
data=self.planning()
observation=dict(scope='linux.apt.planning',quality='valid',completeness='complete',truncated=False,observed_at=m.now().isoformat(),data=data)
self.assertEqual(advanced.planning_from_device(dict(inventory=dict(observations=[observation]))),data)
for changes in (dict(dpkg_updates_empty=False),dict(sealed_baseline_sha256='0'*64),dict(runtime_sha256='0'*64)):
with self.assertRaises(m.GuardError):advanced.planning_from_device(dict(inventory=dict(observations=[dict(observation,data=dict(data,**changes))])))
def test_no_fake_baseline_or_implicit_fixture_removal_to_repeat_acceptance(self):
data=self.planning();data['fixture_package']=dict(version='1.0',status='install ok installed')
with self.assertRaisesRegex(m.GuardError,'no_approved_removal'):m.case_input('apt_native_install',self.settings(),planning=data)
data=self.planning(True);data['fixture_package']=dict(version='1.1',status='install ok installed')
data['baseline']['rmm-mvp-test:all']=data['fixture_package']
data['baseline_sha256']=advanced.digest(advanced.canonical(data['baseline']))
data['sealed_baseline_sha256']=data['baseline_sha256']
self.assertEqual(m.case_input('apply_updates',self.settings(),planning=data)['parameters']['apt_manifest']['resolved_apt_transaction']['packages'][0]['new_version'],'1.1')
self.assertEqual(m.case_input('ensure_package',self.settings(),planning=data)['parameters']['version'],'1.1')
def test_final_upgrade_generated_program_has_real_dependencies_and_sanitized_errors(self):
import io
from contextlib import redirect_stdout
with tempfile.TemporaryDirectory() as folder:
path=Path(folder);(path/'identity').write_text('PRIVATE-UPGRADE-CANARY')
code=upgrade.program('(sha(b"known"),manifest(Path('+repr(folder)+')))')
output=io.StringIO()
with redirect_stdout(output):exec(compile(code,'<final-upgrade>','exec'),{})
result=json.loads(output.getvalue())
self.assertEqual(result['result'],[upgrade.sha(b'known'),upgrade.previous.manifest(path)])
self.assertNotIn('PRIVATE-UPGRADE-CANARY',output.getvalue())
output=io.StringIO()
with redirect_stdout(output):exec(compile(upgrade.program("(_ for _ in ()).throw(ValueError('PRIVATE-UPGRADE-ERROR'))"),'<final-upgrade>','exec'),{})
result=json.loads(output.getvalue());self.assertEqual(result['error']['exception_class'],'ValueError')
self.assertNotIn('PRIVATE-UPGRADE-ERROR',output.getvalue())
def test_real_cancel_expiry_and_reboot_plans_have_fixed_noop_or_explicit_root(self):
start=m.now()
cancel=m.case_input('cancel_queued',self.settings(),start)
self.assertEqual(m.timestamp(cancel['schedule']['not_before'])-start,dt.timedelta(minutes=3))
expiry=m.case_input('expired_offline',self.settings(),start)
self.assertEqual(m.timestamp(expiry['schedule']['start_before'])-start,dt.timedelta(seconds=60))
reboot=m.case_input('reboot_last',self.settings(),start)
self.assertEqual(reboot['action'],'reboot');self.assertEqual(reboot['parameters']['execution_identity'],'root')
self.assertEqual(reboot['parameters']['reconnect_timeout_seconds'],180)
def test_no_native_actor_or_server_restart_from_readonly_default(self):
with patch.object(sys,'argv',['vm_mvp_acceptance.py']),patch.object(m,'default_config',return_value=self.settings()), \
patch.object(m,'Backend') as backend,patch.object(m,'preflight',return_value=({},{})), \
patch.object(native,'OwnedRuntime') as actor:
m.main();actor.assert_not_called();backend.assert_called_once()
def test_native_action_requires_independent_helper_policy_no_capability_override(self):
actor=object.__new__(native.OwnedRuntime);actor.settings=self.settings()
request=m.case_input('reboot_last',self.settings())
capabilities=['reboot','rmm.sync.v1','helper.root.v1','root:reboot','helper.policy.sha256:'+'a'*64]
actor.backend=SimpleNamespace(call=lambda *args:dict(capabilities=capabilities))
actor.wait_sync=lambda:dict(helper_ready=True)
actor.control_probe=lambda *args:dict(policy_sha256='a'*64,policy=dict(allow_reboot=False))
with self.assertRaisesRegex(m.GuardError,'allow_reboot_false'):actor.require_action(request)
def test_cancel_adapter_orders_pause_approve_cancel_resume_without_new_attempt(self):
events=[];checkpoint=dict(job_id='44444444-4444-4444-8444-444444444444',operation_id='55555555-5555-4555-8555-555555555555',
attempt_id='66666666-6666-4666-8666-666666666666',plan_hash='a'*64)
class Backend:
def outstanding_guard(self,settings):events.append('guard')
def call(self,name,args):
events.append(name)
return {} if name=='inventory.get_device' else dict(state='cancelled')
def counts(self,*args):return [1,1,0]
actor=SimpleNamespace(require_action=lambda request:events.append('require_action'),server_state=lambda:dict(boot_id='old'),
pause_idle=lambda:events.append('pause'),resume_after_offline=lambda job:events.append('resume'))
with tempfile.TemporaryDirectory() as folder,patch.object(advanced,'authorize',side_effect=lambda *a,**k:events.append('ui_approve') or checkpoint), \
patch.object(advanced,'wait_job',return_value=dict(state='cancelled')),patch.object(advanced,'audit',return_value={}):
advanced.execute_advanced(Backend(),self.settings(),self.artifact(),'cancel_queued',Path(folder),actor)
self.assertLess(events.index('pause'),events.index('ui_approve'))
self.assertLess(events.index('ui_approve'),events.index('jobs.cancel'))
self.assertLess(events.index('jobs.cancel'),events.index('resume'))
def test_fault_cases_never_create_an_extra_plan_or_claim_injection_passed(self):
backend=SimpleNamespace(outstanding_guard=lambda settings:None,call=lambda *args:(_ for _ in ()).throw(AssertionError('no new MCP plan')))
actor=SimpleNamespace(replay_original_result=lambda checkpoint:dict(regression_verified=True))
with tempfile.TemporaryDirectory() as folder:
folder=Path(folder);m.write_private(folder/'hello-result.json',dict(job_id='test'))
advanced.execute_advanced(backend,self.settings(),self.artifact(),'lost_result_ack',folder,actor)
result=m.protected_json(folder/'lost_result_ack-result.json')
self.assertFalse(result['native_fault_test_passed'])
self.assertEqual(result['fault_injection'],'unsupported_native_fault_injection')
def test_chat_permission_is_never_a_native_readiness_boolean(self):
artifact=self.artifact()
self.assertNotIn('wiring_verified',artifact)
with self.assertRaises(m.GuardError):m.validate_run_artifact(dict(artifact,wiring_verified=True),self.settings(),['hello'])
with self.assertRaises(m.GuardError):native.OwnedRuntime(self.settings(),None,dict(agent_id=self.settings()['agent_id'],ready=True))
def test_bootstrap_cannot_start_foreign_units_or_sample_business_baseline(self):
actor=object.__new__(native.OwnedRuntime)
actor.verdict=dict(helper_units={'sshd.service':'a'*64})
actor.remote=lambda code:(_ for _ in ()).throw(AssertionError('must not dispatch'))
with self.assertRaises(m.GuardError):actor.start_helpers()
source=Path(native.__file__).read_text()
self.assertNotIn('prepare-baseline',source)
self.assertNotIn('provision-fixture-store',source)
self.assertNotIn('dpkg-query',source)
self.assertNotIn('os.kill(',source)
def test_planning_projection_fits_bounded_observation_without_raw_inventory(self):
data=self.planning();data.pop('baseline');data.pop('status_records')
observation=dict(scope='linux.apt.planning',quality='valid',completeness='complete',truncated=False,observed_at=m.now().isoformat(),data=data)
self.assertLess(len(advanced.canonical(data)),32768)
self.assertEqual(advanced.planning_from_device(dict(inventory=dict(observations=[observation]))),data)
def test_native_replay_program_compiles_and_keeps_same_result_attempt_and_grant(self):
actor=object.__new__(native.OwnedRuntime);actor.settings=self.settings()
checkpoint=dict(job_id='44444444-4444-4444-8444-444444444444',attempt_id='55555555-5555-4555-8555-555555555555')
actor.backend=SimpleNamespace(call=lambda *a:dict(state='succeeded'),counts=lambda *a:[1,1,1],sql=lambda *a:'1')
actor.server_state=lambda:dict(fingerprint='a'*64)
def capture(body):
compile(body,'<native-original-result-replay>','exec')
self.assertIn('SELECT envelope FROM reconcile_results',body)
self.assertIn('result=fields(outer[25][0])',body)
self.assertIn("server_hostname='rmm-dev.internal'",body)
self.assertNotIn('UPDATE ',body)
return dict(message_id='66666666-6666-4666-8666-666666666666')
actor.remote=capture
result=actor.replay_original_result(checkpoint)
self.assertTrue(result['regression_verified']);self.assertEqual(result['server_receipts'],1)
def test_runtime_readiness_script_is_effect_free_until_explicit_acquire(self):
actor=object.__new__(native.OwnedRuntime)
def capture(body):
compile(body,'<native-technical-inspect>','exec')
self.assertNotIn('prepare-baseline',body);self.assertNotIn('dpkg-query',body)
self.assertNotIn('systemctl\',\'start',body)
return dict(pid=0)
actor.remote=capture
self.assertEqual(actor.inspect(),dict(pid=0))
def test_root_requester_uses_human_UI_preparation_not_automation_scope_override(self):
settings=self.settings();job='44444444-4444-4444-8444-444444444444';attempt='55555555-5555-4555-8555-555555555555'
operation='66666666-6666-4666-8666-666666666666';raw=b'{"fixture":true}';hash_value=hashlib.sha256(raw).hexdigest()
plan=dict(plan_hash=hash_value,plan_payload_bytes=list(raw),jobs=[dict(job_id=job,attempt_id=attempt,
agent_id=settings['agent_id'],asset_id=settings['asset_id'],job_payload_hash='a'*64,payload=dict(execution_identity='root'))])
pending=dict(operation_id=operation,approval_state='pending_approval',job_count=0,execution_state=None)
calls=[]
def call(name,args):
calls.append(name);self.assertEqual(name,'jobs.get')
return dict(plan_hash=hash_value,approval_state='pending_approval')
backend=SimpleNamespace(call=call,counts=lambda *a:[0,0,0])
with tempfile.TemporaryDirectory() as folder:
folder=Path(folder)
def browser(argv,**kwargs):
if '--prepare-only' in argv:
m.write_private(folder/'service_start-prepared.json',dict(plan=plan,operation=pending))
else:
checkpoint=m.protected_json(folder/'service_start-checkpoint.json')
self.assertEqual(checkpoint['job_id'],job)
return SimpleNamespace(returncode=0)
with patch.object(advanced.subprocess,'run',side_effect=browser):
result=advanced.authorize(backend,settings,self.artifact(),'service_start',folder,m.case_input('service_start',settings))
self.assertEqual(result['operation_id'],operation)
self.assertEqual(calls,['jobs.get'])
def test_apt_profile_cannot_hide_consumption_in_a_private_ledger_copy(self):
actor=object.__new__(native.OwnedRuntime)
common=dict(ledger_device=1,ledger_inode=2,lock_device=1,lock_inode=3)
actor.control_probe=lambda profile:dict(common,ledger_inode=4) if profile=='apt_only' else common
with self.assertRaisesRegex(m.GuardError,'exact_ledger'):actor.apt_probe()
actor.control_probe=lambda profile:common
self.assertEqual(actor.apt_probe(),common)
if __name__=='__main__':unittest.main()