#!/usr/bin/env python3 """Rotate the existing Linux development helper after the signed agent pair has switched.""" import argparse import fcntl import json import os from pathlib import Path import re import shlex import stat import subprocess import sys import tempfile import time import uuid ROOT = Path('/opt/rust-discovery-client') CONFIG = Path('/etc/rmm-discovery-managed-scripts') UNIT = Path('/etc/systemd/system/rmm-discovery-managed-script-helper.service') AGENT = 'rmm-discovery-agent.service' TIMER = 'rmm-discovery-update.timer' POLICY = Path('/opt/rust-discovery/devstate/managed-scripts/policy.json') HASH = re.compile(r'[0-9a-f]{64}') PINS = ('helper_binary_sha256', 'helper_policy_sha256') def require(test, error): if not test: raise ValueError(error) def encoded(obj): return (json.dumps(obj, separators=(',', ':')) + '\n').encode() def protected(path, uid=0): for parent in path.parents: info = parent.lstat() require(stat.S_ISDIR(info.st_mode) and info.st_uid in (0, uid) and not info.st_mode & 0o022, f'Untrusted directory: {parent}') info = path.lstat() require(stat.S_ISREG(info.st_mode) and info.st_uid == uid and not info.st_mode & 0o022, f'Untrusted file: {path}') return info def replace(path, data): info = path.lstat() if path.read_bytes() == data: return fd, name = tempfile.mkstemp(dir=path.parent) try: with os.fdopen(fd, 'wb') as stream: os.fchown(stream.fileno(), info.st_uid, info.st_gid) os.fchmod(stream.fileno(), stat.S_IMODE(info.st_mode)) stream.write(data) stream.flush() os.fsync(stream.fileno()) os.replace(name, path) finally: Path(name).unlink(missing_ok=True) directory = os.open(path.parent, os.O_RDONLY | os.O_DIRECTORY) try: os.fsync(directory) finally: os.close(directory) def run(*args, **kwargs): return subprocess.check_output(args, timeout=120, **kwargs) def prop(unit, field): return run('systemctl', 'show', '--property', field, '--value', unit).decode().strip() def process_image(service): pid = int(prop(service, 'MainPID')) return Path(f'/proc/{pid}/exe').resolve(strict=True) if pid else None def pair(release_id): release = ROOT / 'releases' / release_id names = ('envelope.json', 'agent', 'helper', 'manifest.json') for name in names: protected(release / name) manifest = json.loads(run(ROOT / 'updater', '--verify-bootstrap', ROOT / 'keyring.json', release / 'envelope.json', release / 'agent', release / 'helper')) require(manifest == json.loads((release / 'manifest.json').read_bytes()) and manifest['release_id'] == release_id and manifest['platform'] == 'x86_64-unknown-linux-gnu', 'Signed release binding mismatch') helper, = [x for x in manifest['artifacts'] if x['role'] == 'helper'] return release, manifest, helper['sha256'] def repoint_unit(contents, old, new, destination): lines = contents.splitlines(keepends=True) paths = [f'ExecStart={path}/helper\n'.encode() for path in (old, new)] starts = [i for i, line in enumerate(lines) if line.startswith(b'ExecStart=')] require(len(starts) == 1 and lines[starts[0]] in paths, 'Unexpected managed helper ExecStart') lines[starts[0]] = f'ExecStart={destination}/helper\n'.encode() return b''.join(lines) def device(args, activate): require(os.geteuid() == 0, 'Linux maintenance requires the development administrator') for path in [ROOT / n for n in ('updater', 'keyring.json', 'release.lock', 'config.json', 'lifecycle.py')]: protected(path) with (ROOT / 'release.lock').open('rb') as guard: fcntl.flock(guard, fcntl.LOCK_EX | fcntl.LOCK_NB) require(prop(TIMER, 'ActiveState') == 'inactive' and prop('rmm-discovery-update.service', 'ActiveState') == 'inactive', 'Pause the update timer and wait for the running release check') old, old_manifest, old_hash = pair(args.previous) new, manifest, new_hash = pair(args.current) require((ROOT/'current').resolve(strict=True) == new and old_hash != new_hash and manifest['release_sequence'] > old_manifest['release_sequence'], 'Unexpected active release pair') require(json.loads((ROOT/'config.json').read_bytes())['tenant'] == args.tenant, 'Wrong installed tenant') identity = json.loads(run('runuser', '-u', 'rmm-discovery', '--', 'cat', '/var/lib/rmm-discovery/identity.json')) require(identity['agent_id'] == args.agent and identity['asset_id'] == args.asset, 'Wrong device') require(run('runuser', '-u', 'rmm-discovery', '--', 'python3', '-I', ROOT/'lifecycle.py', 'idle').strip() == b'idle', 'Unresolved device attempt') cfg, proof = CONFIG/'helper.json', CONFIG/'agent-pin.json' for path in (UNIT, cfg, proof): protected(path) command = prop(UNIT.name, 'ExecStart') paths = (old/'helper', new/'helper') effective = [path for path in paths if f'path={path} ; argv[]={path} ;' in command] require(prop(UNIT.name, 'FragmentPath') == str(UNIT) and len(effective) == 1 and command.count('argv[]=') == 1 and 'RMM_HELPER_CONFIG=' + str(cfg) in shlex.split(prop(UNIT.name, 'Environment')), 'Unexpected effective managed helper configuration') require(process_image(UNIT.name) in (*paths, None) and process_image(AGENT) in (new/'agent', None), 'Running process does not match either signed generation') settings = json.loads(cfg.read_bytes()) binding = {k: settings['binding'][k] for k in ('tenant_id', 'agent_id', 'asset_id', 'enrollment_generation', 'assignment_version')} require((binding['tenant_id'], binding['asset_id'], binding['agent_id']) == (args.tenant, args.asset, args.agent) and settings['profile'] == 'full_maintenance_v1' and settings[PINS[0]] in (old_hash, new_hash), 'Wrong managed profile or helper hash') pin = json.loads(proof.read_bytes()) candidates = [] with tempfile.TemporaryDirectory(dir=CONFIG) as work: temp = Path(work)/'helper.json' for folder, binary in [(old, old_hash), (new, new_hash)]: profile = encoded(dict(settings, helper_binary_sha256=binary)) temp.write_bytes(profile) temp.chmod(0o600) native = run(folder/'helper', '--inspect-full-maintenance-profile', env={'PATH':'/usr/bin:/bin', 'RMM_HELPER_CONFIG':str(temp)}) computed = json.loads(native) require(computed['helper_binary_sha256'] == binary and HASH.fullmatch(computed['policy_sha256']), 'Native profile verification failed') candidates.append((profile, native, computed)) source, target = candidates require(pin in [source[2], target[2]] and {k:v for k,v in source[2].items() if k not in ('policy_sha256', PINS[0])} == {k:v for k,v in target[2].items() if k not in ('policy_sha256', PINS[0])}, 'Existing and proposed proof must bind the same profile and identity') undo = args.action == 'rollback' profile, native, chosen = source if undo else target destination = old if undo else new unit = repoint_unit(UNIT.read_bytes(), old, new, destination) if activate: running = process_image(UNIT.name) == destination/'helper' and process_image(AGENT) == new/'agent' if not (settings[PINS[0]] == chosen[PINS[0]] and pin == chosen and UNIT.read_bytes() == unit and running): run('systemctl', 'stop', AGENT, UNIT.name) replace(cfg, profile) replace(proof, native) replace(UNIT, unit) run('systemctl', 'daemon-reload') run('systemctl', 'start', UNIT.name, AGENT) # The agent unit starts its Python launcher before exec'ing the signed binary. deadline = time.monotonic() + 15 for service, expected in [(UNIT.name, destination/'helper'), (AGENT, new/'agent')]: while process_image(service) != expected: require(time.monotonic() < deadline, f'{service} did not start its verified binary') time.sleep(0.2) return dict(binding=binding, version=manifest['version'], previous=[old_hash, source[2]['policy_sha256']], current=[new_hash, target[2]['policy_sha256']]) def existing_scope(policy, receipt): require(policy['schema_version'] == 1, 'Unknown scope format') scopes = [s for s in policy['linux'] if s['agent_id'] == receipt['binding']['agent_id']] require(len(scopes) == 1, 'Exactly one pre-existing scope is required') scope = scopes[0] require(all(scope[k] == v for k,v in receipt['binding'].items()) and [scope[k] for k in PINS] in (receipt['previous'], receipt['current']), 'Existing scope changed') return scope def server(args, receipt, activate): require([receipt['binding'][k] for k in ('tenant_id','asset_id','agent_id')] == [args.tenant,args.asset,args.agent], 'Wrong scope receipt') for pins in [receipt['previous'], receipt['current']]: require(len(pins) == 2 and all(HASH.fullmatch(x) for x in pins), 'Invalid helper hashes') owner = (POLICY.parent.parent/'jobs/ed25519.pem').stat().st_uid directory = POLICY.parent.lstat() require(stat.S_ISDIR(directory.st_mode) and directory.st_uid == owner and not directory.st_mode & 0o077, 'Invalid managed policy directory') lock = POLICY.parent/'operator.lock' for path in (POLICY, lock): info = path.lstat() require(stat.S_ISREG(info.st_mode) and info.st_uid in (0, owner) and not info.st_mode & 0o022, 'Invalid managed policy file') wanted = receipt['previous' if args.action == 'rollback' else 'current'] query = """BEGIN READ ONLY; SELECT json_build_object('generation',enrollment_generation,'assignment',assignment_version, 'fresh',sync_ready AND helper_sync_ready AND NOT restore_blocked AND last_authenticated_at > now()-interval '2 minutes' AND certificate_sha256=last_authenticated_certificate_sha256, 'version',reported_agent_version,'caps',capabilities, 'idle',NOT EXISTS(SELECT 1 FROM jobs j WHERE j.agent_id=i.agent_id AND j.tenant_id=i.tenant_id AND j.state NOT IN ('succeeded','failed','cancelled','expired','closed_unknown'))) FROM agent_installations i WHERE tenant_id=:'tenant' AND asset_id=:'asset' AND agent_id=:'agent' AND revoked_at IS NULL; COMMIT;""" deadline = time.monotonic()+120 while True: with lock.open('rb') as guard: fcntl.flock(guard, fcntl.LOCK_EX) policy = json.loads(POLICY.read_bytes()) scope = existing_scope(policy, receipt) state = json.loads(run('docker','exec','-i','rust-discovery-server-postgres-1','psql','-XqAt', '-U','postgres','-d','rmm','-v','ON_ERROR_STOP=1', '-v',f'tenant={args.tenant}','-v',f'asset={args.asset}','-v',f'agent={args.agent}', input=query.encode())) require(state['idle'] and state['generation'] == scope['enrollment_generation'] and state['assignment'] == scope['assignment_version'], 'Unresolved job or changed enrollment') if not activate: return {'existing_scope':True} if state['fresh'] and state['version'] == receipt['version'] and all( p in state['caps'] for p in ['helper.binary.sha256:'+wanted[0],'helper.policy.sha256:'+wanted[1]]): if [scope[k] for k in PINS] != wanted: scope.update(zip(PINS,wanted)) replace(POLICY, encoded(policy)) return {'scoped_helper_binary':wanted[0],'scoped_helper_policy':wanted[1]} require(time.monotonic()