Qualify tenant-scoped bootstrap rotation and fresh Windows scripting

This commit is contained in:
2026-11-17 16:19:08 +01:00
parent 81fcd9c8f8
commit fbd24b6d75
26 changed files with 877 additions and 118 deletions
+28 -1
View File
@@ -1,7 +1,9 @@
"""Retry coverage for the HTTPS Linux bootstrap without installing on the test host."""
from contextlib import ExitStack
from contextlib import ExitStack, redirect_stdout
from importlib.util import module_from_spec, spec_from_file_location
import io
import json
import sqlite3
from pathlib import Path
import tempfile
import unittest
@@ -29,12 +31,26 @@ class EnrollmentRetry(unittest.TestCase):
for field, value in [('ROOT',root),('STATE',self.state)]:
self.stack.enter_context(patch.object(lifecycle,field,value))
self.enable = self.stack.enter_context(patch.object(lifecycle,'enable'))
self.service = self.stack.enter_context(patch.object(lifecycle,'service'))
self.healthy = self.stack.enter_context(patch.object(lifecycle,'healthy',return_value=True))
self.save = self.stack.enter_context(patch.object(lifecycle,'save_token'))
self.stack.enter_context(patch.object(lifecycle.pwd,'getpwnam'))
self.token = folder / 'retry.token'
self.token.write_text('0' * 64)
def test_unresolved_effects_delay_release_without_blocking_closed_jobs(self):
with sqlite3.connect(self.state / 'journal.sqlite') as db:
db.execute('CREATE TABLE job_attempts (state TEXT)')
for state, expected in [('running','busy'), ('unknown','busy'), ('awaiting_reboot','busy'),
('closed_unknown','idle'), ('accepted','idle'), ('succeeded','idle')]:
with self.subTest(state=state):
db.execute('DELETE FROM job_attempts')
db.execute('INSERT INTO job_attempts VALUES(?)', (state,))
db.commit()
with redirect_stdout(io.StringIO()) as output:
lifecycle.device_idle()
self.assertEqual(output.getvalue().strip(), expected)
def bootstrap_tenant(self, tenant):
def answer(source, route, target):
self.assertEqual(source, (self.base,'0' * 64))
@@ -57,6 +73,17 @@ class EnrollmentRetry(unittest.TestCase):
self.save.assert_called_once()
self.healthy.assert_called_once_with('1.0',0)
def test_timer_starts_only_after_confirmed_first_connection(self):
self.bootstrap_tenant(self.tenant)
self.healthy.return_value = False
with self.assertRaisesRegex(ValueError, 'awaiting authenticated device heartbeat'):
lifecycle.install(self.base,self.token)
self.enable.assert_called_once()
self.service.assert_not_called()
self.healthy.return_value = True
lifecycle.install(self.base,self.token)
self.service.assert_called_once_with('enable','--now',lifecycle.TIMER)
def test_token_for_another_tenant_cannot_replace_initial_token(self):
self.bootstrap_tenant('22222222-2222-4222-8222-222222222222')
with self.assertRaisesRegex(ValueError,'different enrollment tenant'):
+229
View File
@@ -0,0 +1,229 @@
"""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)