245 lines
13 KiB
Python
245 lines
13 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
|
|
worker_build = directory/'worker-only'
|
|
worker_build.mkdir()
|
|
worker_name = release.FILES[release.LINUX][2]
|
|
(worker_build/worker_name).write_bytes(replacement_worker)
|
|
worker_receipt = worker_build/'manifest.json'
|
|
worker_receipt.write_text(json.dumps({'target':release.LINUX,'sha256':{worker_name:new['sha256']}}))
|
|
login_file = directory/'catalog-login.json'
|
|
with open(login_file, 'x', opener=lambda path, flags: os.open(path, flags, 0o600)) as login:
|
|
json.dump({'username':env['RMM_DEV_USERNAME'],'password':env['RMM_DEV_PASSWORD']},login)
|
|
def rotate(predecessor):
|
|
release.publish(SimpleNamespace(artifacts=worker_build,build_receipt=worker_receipt,rotate_worker_only=True,
|
|
envelope=None,bootstrap_worker=None,rotate_bootstrap_from=predecessor,bootstrap_state=state,origin=origin,
|
|
ca=tls/'ca.pem',dev_login_file=login_file,tenant=TENANT))
|
|
published_before = ask('GET',path+'/agent-releases',headers=auth)[1]['items']
|
|
assert [item['release_envelope'] for item in published_before] == [a]
|
|
try:
|
|
rotate('0'*64)
|
|
raise AssertionError('unexpected predecessor accepted')
|
|
except ValueError:
|
|
pass
|
|
assert updater()==original_worker
|
|
rotate(original['sha256'])
|
|
rotate(original['sha256'])
|
|
assert ask('GET',path+'/agent-releases',headers=auth)[1]['items'] == published_before
|
|
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('worker-only publication preserves the signed release, tenant isolation and in-flight downloads; stale predecessor rejected')
|
|
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)
|