Qualify tenant-scoped bootstrap rotation and fresh Windows scripting
This commit is contained in:
@@ -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'):
|
||||
|
||||
@@ -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)
|
||||
Reference in New Issue
Block a user