"""Exercise release publication and fresh enrollment on disposable loopback TLS/PostgreSQL.""" import argparse import base64 from contextlib import ExitStack import hashlib import http.client from http.cookies import SimpleCookie import json import os from pathlib import Path import secrets import shutil import socket import ssl import subprocess import sys import tempfile import time from types import SimpleNamespace from urllib.parse import urlencode import uuid ROOT = Path(__file__).resolve().parents[1] sys.path.insert(0, str(ROOT / 'tools')) import agent_release as release TENANT = '11111111-1111-4111-8111-111111111111' def run(*cmd, data=None): return subprocess.run(cmd, input=data, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True).stdout def test(binary, directory, stack): db = 'rmm-bootstrap-' + uuid.uuid4().hex[:12] password = secrets.token_hex(24) run('docker','run','-d','--name',db,'-e','POSTGRES_PASSWORD=' + password,'-p','127.0.0.1::5432','postgres:17.6-bookworm') stack.callback(run,'docker','rm','-f',db) for _ in range(80): if b'init process complete' in run('docker','logs',db) and subprocess.run( ['docker','exec',db,'pg_isready','-U','postgres'],stdout=subprocess.DEVNULL).returncode == 0: break time.sleep(.25) port = run('docker','port',db,'5432/tcp').decode().strip().split(':')[-1] def sql(role, database, script): return run('docker','exec','-i',db,'psql','-XAtq','-v','ON_ERROR_STOP=1','-U',role,'-d',database,data=script.encode()).decode().strip() sql('postgres','postgres', f"""CREATE ROLE rmm_migrator LOGIN NOSUPERUSER NOBYPASSRLS PASSWORD '{password}'; CREATE ROLE rmm_app LOGIN NOSUPERUSER NOBYPASSRLS PASSWORD '{password}'; CREATE DATABASE rmm OWNER rmm_migrator;""") sql('postgres','rmm','ALTER SCHEMA public OWNER TO rmm_migrator; REVOKE CREATE ON SCHEMA public FROM PUBLIC;') for migration in sorted((ROOT/'migrations').glob('*.sql')): sql('rmm_migrator','rmm',migration.read_text()) assert sql('rmm_migrator','rmm',"SELECT NOT rolsuper AND NOT rolbypassrls FROM pg_roles WHERE rolname=current_user") == 't' def permissions(): return sql('rmm_app','rmm',f"""BEGIN; SET LOCAL app.tenant_id='{TENANT}'; SELECT ('devices:enroll'=ANY(permissions))::int FROM memberships WHERE principal='simulated-testprincipal-a'; COMMIT;""") assert permissions() == '1', 'migration 0025 must grant devices:enroll through tenant RLS' print('Migrations and enrollment permission verified with NOSUPERUSER NOBYPASSRLS migration owner') artifacts = directory/'bin' artifacts.mkdir() files = ('/bin/true','/bin/false','/usr/bin/env') state = directory/'release' def make_release(sequence): for name, system_file in zip(release.FILES[release.LINUX], files): shutil.copyfile(system_file,artifacts/name) helper=artifacts/release.FILES[release.LINUX][1] with helper.open('ab') as f: f.write(bytes([sequence])) hashes={p.name:hashlib.sha256(p.read_bytes()).hexdigest() for p in artifacts.iterdir()} receipt=directory/'receipt.json' receipt.write_text(json.dumps({'sha256':hashes,'target':release.LINUX})) release.prepare(SimpleNamespace(artifacts=artifacts,build_receipt=receipt,service_uid=os.getuid(),state=state, sequence=sequence,version='test.'+str(sequence),gateway='https://localhost',days=1)) env=json.loads((state/'prepared/linux'/str(sequence)/'envelope.json').read_bytes()) return env, json.loads(base64.urlsafe_b64decode(env['payload_bytes']+'===')) a, ma = make_release(1) tls=directory/'tls' tls.mkdir() run('openssl','req','-x509','-newkey','ec','-pkeyopt','ec_paramgen_curve:prime256v1','-nodes','-days','1', '-subj','/CN=Test CA','-addext','basicConstraints=critical,CA:TRUE','-keyout',str(tls/'ca.key'),'-out',str(tls/'ca.pem')) def csr(name): run('openssl','req','-new','-newkey','ec','-pkeyopt','ec_paramgen_curve:prime256v1','-nodes','-subj','/CN='+name, '-keyout',str(tls/(name+'.key')),'-out',str(tls/(name+'.csr'))) csr('server') extensions=tls/'san' extensions.write_text('subjectAltName=DNS:localhost\nextendedKeyUsage=serverAuth\n') run('openssl','x509','-req','-in',str(tls/'server.csr'),'-CA',str(tls/'ca.pem'),'-CAkey',str(tls/'ca.key'), '-CAcreateserial','-days','1','-extfile',str(extensions),'-out',str(tls/'server.pem')) csr('device') with socket.socket() as s: s.bind(('127.0.0.1',0)); http_port=s.getsockname()[1] origin='https://localhost:'+str(http_port) env=dict(os.environ,DATABASE_URL=f'postgres://rmm_app:{password}@127.0.0.1:{port}/rmm', RMM_PROFILE='development',RMM_DEV_AUTH='true',RMM_DEV_USERNAME='acceptance',RMM_DEV_PASSWORD=secrets.token_hex(24), RMM_VIEWER_A=secrets.token_hex(24),RMM_VIEWER_B=secrets.token_hex(24),RMM_SERVER_ROLE='all', RMM_LISTEN_ADDR=f'127.0.0.1:{http_port}',RMM_UI_ORIGIN=origin,RMM_TLS_DIR=str(tls), RMM_JOB_KEY_FILE=str(directory/'job-keys/key.pem'),RMM_AGENT_UPDATE_ARTIFACT_DIR=str(state/'objects'), RMM_AGENT_UPDATE_LINUX_KEYRING_FILE=str(state/'config/linux-keyring.json'), RMM_AGENT_BOOTSTRAP_LINUX_FILE=str(state/'config/linux-bootstrap.json'),RMM_BOOTSTRAP_ORIGIN=origin) log=stack.enter_context((directory/'server.log').open('w+')) server=subprocess.Popen([binary],cwd=directory,env=env,stdout=log,stderr=log) def stop_server(): if server.poll() is None: server.terminate() server.wait(timeout=15) stack.callback(stop_server) ctx=ssl.create_default_context(cafile=str(tls/'ca.pem')) def ask(method,path,body=None,headers=None,status=200): conn=http.client.HTTPSConnection('localhost',http_port,context=ctx,timeout=10) try: headers=dict(headers or {}) if isinstance(body,dict): body=json.dumps(body).encode();headers['Content-Type']='application/json' conn.request(method,path,body=body,headers=headers) response=conn.getresponse();raw=response.read() expected=(status,) if isinstance(status,int) else status assert response.status in expected, (method,path.split('?')[0],response.status,expected) return response.headers, json.loads(raw) if response.getheader('content-type','').startswith('application/json') else raw finally: conn.close() for _ in range(70): if server.poll() is not None: log.seek(0); raise RuntimeError(log.read()) try: ask('GET','/healthz') break except OSError: time.sleep(.1) hdr,_=ask('POST','/auth/dev/login',{'username':'acceptance','password':env['RMM_DEV_PASSWORD']},{'Origin':origin}) cookie=SimpleCookie(hdr['set-cookie'])['__Host-rmm_session'].value auth={'Cookie':'__Host-rmm_session='+cookie,'Origin':origin} _,session=ask('GET','/auth/session',headers=auth) auth['X-CSRF-Token']=session['csrf_token'] path='/api/v1/tenants/'+TENANT def upload(blob, data, status=200): query=urlencode({'artifact_id':blob['artifact_id'],'sha256':blob['sha256'],'size_bytes':blob['bytes']}) ask('POST',path+'/agent-update-artifacts?'+query,data,{**auth,'Content-Type':'application/octet-stream'},status) def stable_blob(data): return {'artifact_id':str(uuid.uuid4()),'sha256':hashlib.sha256(data).hexdigest(),'bytes':len(data)} original_worker=(artifacts/'rmm-agent-updater').read_bytes() original=stable_blob(original_worker) upload(original,original_worker) def send_pair(manifest): for name,blob in zip(release.FILES[release.LINUX],manifest['artifacts']): upload(blob,(artifacts/name).read_bytes()) send_pair(ma) ask('POST',path+'/agent-releases',a,auth) ask('POST',path+'/agent-releases',a,auth) b,mb=make_release(2) upload(mb['artifacts'][0],(artifacts/'rmm-agent').read_bytes()) ask('POST',path+'/agent-releases',b,auth,404) partial=mb['artifacts'][1] upload(partial,(artifacts/'rmm-privileged-helper').read_bytes()[:-1],400) ask('POST',path+'/agent-releases',b,auth,404) h,token=ask('POST',path+'/enrollment-tokens',{},auth) assert 'no-store' in h['Cache-Control'] bootstrap='/agent/v1/bootstrap/current?platform='+release.LINUX credential={'Authorization':'Enrollment '+token['token']} _,active=ask('GET',bootstrap,headers=credential) assert active['manifest']['release_id']==ma['release_id'] and active['job_signing_public_key_hex'] assert active['tenant_id']==TENANT ask('GET',bootstrap,headers={'Authorization':'Enrollment '+'0'*64},status=401) blob=ma['artifacts'][0] download=f"/agent/v1/bootstrap/releases/{ma['release_id']}/artifacts/{blob['artifact_id']}?platform={release.LINUX}" _,raw=ask('GET',download,headers=credential) assert hashlib.sha256(raw).hexdigest()==blob['sha256'] def updater(digest=None, status=200): return ask('GET','/agent/v1/bootstrap/updater?platform='+release.LINUX+('&sha256='+digest if digest else ''), headers=credential,status=status)[1] assert updater()==original_worker replacement_worker=original_worker+b'test-new-worker' new=stable_blob(replacement_worker) pin={'sha256':new['sha256'],'bytes':new['bytes']} try: release.rotate_pin(state,'linux',TENANT,original['sha256'],pin) raise AssertionError('missing upload changed pointer') except FileNotFoundError: pass assert updater()==original_worker upload(new,replacement_worker) try: release.rotate_pin(state,'linux',TENANT,'0'*64,pin) raise AssertionError('unexpected predecessor accepted') except ValueError: pass assert updater()==original_worker release.rotate_pin(state,'linux',TENANT,original['sha256'],pin) release.rotate_pin(state,'linux',TENANT,original['sha256'],pin) assert updater()==replacement_worker and updater(original['sha256'])==original_worker assert ask('GET',bootstrap,headers=credential)[1]['updater']==pin updater('0'*64,404) assert json.loads((state/'config/linux-bootstrap.json').read_bytes())['updater_sha256']==original['sha256'] # Set up B's already published default worker. This fixture has only one # interactive dev principal (tenant A), so seed the independent tenant directly. tenant_b='22222222-2222-4222-8222-222222222222' token_b=secrets.token_hex(32) sql('rmm_app','rmm',f"BEGIN; SET LOCAL app.tenant_id='{tenant_b}'; SELECT issue_enrollment_token('{hashlib.sha256(token_b.encode()).hexdigest()}'); COMMIT;") b_store=state/'objects'/tenant_b b_store.mkdir(mode=0o700) shutil.copy2(state/'objects'/TENANT/original['sha256'],b_store/original['sha256']) b_auth={'Authorization':'Enrollment '+token_b} assert ask('GET','/agent/v1/bootstrap/updater?platform='+release.LINUX,headers=b_auth)[1]==original_worker ask('GET','/agent/v1/bootstrap/updater?platform='+release.LINUX+'&sha256='+new['sha256'],headers=b_auth,status=404) print('tenant worker rotation rejects missing object and stale predecessor; default and in-flight downloads survive') install={'token':token['token'],'csr_pem':(tls/'device.csr').read_text()} _,enrolled=ask('POST','/agent/v1/enroll',install) assert enrolled['certificate_pem'] ask('POST','/agent/v1/enroll',install,status=401) ask('GET',bootstrap,headers=credential,status=401) ask('GET',download,headers=credential,status=401) ask('GET','/agent/v1/releases/current?platform='+release.LINUX,status=401) cert = tls/'issued-device.pem' cert.write_text(enrolled['certificate_pem']) ctx.load_cert_chain(str(cert),str(tls/'device.key')) _,trust=ask('GET','/agent/v1/releases/device-trust') assert trust['job_signing_public_key_hex'] == active['job_signing_public_key_hex'] upload(partial,(artifacts/'rmm-privileged-helper').read_bytes()) ask('POST',path+'/agent-releases',b,auth) print('A stays current after missing/truncated B; B publishes only after complete retry') print('Unknown token, second enrollment, post-consumption metadata/object fetch and absent mTLS rejected') if __name__ == '__main__': parser=argparse.ArgumentParser(description=__doc__) parser.add_argument('--server-binary',required=True,type=Path) args=parser.parse_args() with ExitStack() as cleanup: folder=Path(cleanup.enter_context(tempfile.TemporaryDirectory())) test(args.server_binary.resolve(),folder,cleanup)