Files
rust-discovery/tests/release_bootstrap_gateway.py
T

230 lines
12 KiB
Python

"""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)