Files
rust-discovery/deploy/remote_client_bootstrap.py
T
2026-11-13 13:49:11 +01:00

229 lines
13 KiB
Python

#!/usr/bin/env python3
"""Create separate clients for the dedicated server; never execute RMM jobs.
Old VM identities, helpers, services and journals remain untouched. Each new
installation is create-only; failures retain state for inspection, not reenroll.
Server secrets stay on the server. Only a single-use token and public trust
material are transferred over independently verified SSH.
"""
import argparse
import base64
import hashlib
import inspect
import json
import os
from pathlib import Path
import pwd
import subprocess
import time
import uuid
import vm_access_check as access
ROOT = access.ROOT
TENANT = '11111111-1111-4111-8111-111111111111'
DOMAIN = 'discovery.ease-technologies.de'
UNIT = 'rmm-agent-remote.service'
def require(value, message):
if not value:
raise RuntimeError(message)
def execute(args, **kwargs):
result = subprocess.run(args, capture_output=True, timeout=40, **kwargs)
require(result.returncode == 0, 'command failed; private diagnostics withheld')
return result.stdout
def rpc(config, function, payload):
cfg = access.load_config(ROOT/'credentials'/config)
ssh = ['ssh', '-F', '/dev/null', '-T', '-p', cfg.get('port', '22'),
'-o', 'StrictHostKeyChecking=yes', '-o', 'BatchMode=yes',
'-o', 'IdentitiesOnly=yes', '-o', 'ForwardAgent=no', '-o', 'ConnectTimeout=10',
'-i', str(Path(cfg['ssh_key_path']).expanduser()), cfg['username']+'@'+cfg['address'], 'python3 -']
code = ('import os,json,subprocess,base64,hashlib,ssl,http.client,socket,uuid,pwd\nfrom pathlib import Path\n' +
inspect.getsource(require) + '\n' + inspect.getsource(function) +
'\ntry:\n print(json.dumps('+function.__name__+'('+repr(payload)+')))\n'
'except Exception as error:\n import traceback\n'
' print(json.dumps(dict(error="REMOTE_BOOTSTRAP_INCOMPLETE",error_class=type(error).__name__, '
'frames=[dict(function=f.name,line=f.lineno) for f in traceback.extract_tb(error.__traceback__)])))\n')
result = json.loads(execute(ssh, input=code.encode()))
if 'error' in result:
# Never expose exception messages, locals, commands or remote stderr.
raise RuntimeError('remote bootstrap incomplete: '+json.dumps({k:result.get(k) for k in ('error_class','frames')}))
return result
def server(payload):
root = Path('/opt/rust-discovery')
command = ['docker', 'compose', '--env-file', str(root/'devstate/.env'),
'-f', str(root/'deploy/server.compose.yaml'), 'exec', '-T', 'postgres',
'psql', '-X', '-qAt', '-v', 'ON_ERROR_STOP=1', '-U', 'postgres', '-d', 'rmm']
if payload['action'] in ('enroll', 'material'):
raw = None
if payload['action'] == 'enroll':
raw = __import__('secrets').token_hex(32)
digest = hashlib.sha256(raw.encode()).hexdigest()
query = ("INSERT INTO enrollment_tokens(token_hash,tenant_id,expires_at) VALUES('"+digest+
"','11111111-1111-4111-8111-111111111111',now()+interval '15 minutes');")
subprocess.run(command, input=query.encode(), capture_output=True, check=True)
# This is a public signing-key endpoint, accessed over verified TLS with
# a private loopback reader. No private central key leaves the server.
class HTTPS(http.client.HTTPSConnection):
def connect(self):
self.sock = self._context.wrap_socket(socket.create_connection(('127.0.0.1', 18443), timeout=10),
server_hostname=self.host)
client = HTTPS('rmm-dev.internal', 18443, context=ssl.create_default_context(cafile=str(root/'devstate/pki/ca.pem')))
client.request('GET', '/api/v1/job-signing-key', headers={'Authorization': 'Bearer '+
(root/'devstate/operator-a.token').read_text().strip()})
response = client.getresponse(); require(response.status == 200, 'signing key endpoint rejected')
key = json.loads(response.read()); client.close()
return dict(token=raw, ca=base64.b64encode((root/'devstate/pki/ca.pem').read_bytes()).decode(), key=key)
agent = str(uuid.UUID(payload['agent_id']))
query = ("SELECT json_build_object('agent_id',agent_id,'asset_id',asset_id,'enrollment_generation',enrollment_generation,"
"'assignment_version',assignment_version,'sync_ready',sync_ready,'restore_blocked',restore_blocked,"
"'last_contact_at',last_contact_at,'connection_generation',connection_generation,'transport',transport,'inventory_received',"
"EXISTS(SELECT 1 FROM observations o WHERE o.tenant_id=a.tenant_id AND o.agent_id=a.agent_id)) "
"FROM agent_installations a WHERE tenant_id='11111111-1111-4111-8111-111111111111' AND agent_id='"+agent+"';")
result = subprocess.run(command, input=query.encode(), capture_output=True, check=True).stdout.strip()
return json.loads(result) if result else {}
def vm(payload):
unit = 'rmm-agent-remote.service'
state = Path('/var/lib/rmm-agent-remote')
config = Path('/etc/rmm-remote')
binary = Path('/usr/local/libexec/rmm-agent-remote')
account = pwd.getpwnam('rmm-agent')
require(os.geteuid() == 0 and account.pw_uid > 0, 'unprivileged agent account required')
if payload['action'] == 'install':
for name in ('rmm-agent.service', 'rmm-helper-dev-test.service', 'rmm-apt-helper.service'):
result = subprocess.run(['systemctl', 'show', name, '-p', 'ActiveState', '--value'], capture_output=True, check=True)
require(result.stdout.strip() == b'inactive', 'old installation is not idle')
target = Path('/etc/systemd/system')/unit
for path in (state, config, binary, target):
require(not path.exists() and not path.is_symlink(), 'existing installation; never reset')
data = base64.b64decode(payload['binary'], validate=True)
require(hashlib.sha256(data).hexdigest() == payload['binary_sha256'] and data[:6] == b'\x7fELF\x02\x01'
and data[18:20] == b'\x3e\x00', 'Linux x86-64 artifact required')
os.umask(0o077)
state.mkdir(mode=0o700); os.chown(state, account.pw_uid, account.pw_gid)
config.mkdir(mode=0o755); config.chmod(0o755)
for path, content, mode, owner in (
(binary, data, 0o755, 0), (config/'ca.pem', base64.b64decode(payload['ca']), 0o644, 0),
(state/'enroll.token', payload['token'].encode(), 0o600, account.pw_uid),
(config/'agent.env', payload['environment'].encode(), 0o600, 0),
(target, payload['unit'].encode(), 0o644, 0)):
fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, mode)
with os.fdopen(fd, 'wb') as stream:
stream.write(content); stream.flush(); os.fsync(stream.fileno())
os.chown(path, owner, account.pw_gid if owner else 0)
path.chmod(mode)
subprocess.run(['/lib64/ld-linux-x86-64.so.2', '--list', str(binary)], capture_output=True, check=True)
subprocess.run(['systemd-analyze', 'verify', str(target)], capture_output=True, check=True)
subprocess.run(['systemctl', 'daemon-reload'], capture_output=True, check=True)
return dict(installed=True, uid=account.pw_uid)
if payload['action'] in ('start', 'stop', 'enable'):
subprocess.run(['systemctl', payload['action'], unit], capture_output=True, check=True)
return {}
if payload['action'] == 'identity':
path = state/'identity.json'
if not path.exists():
return {}
identity = json.loads(path.read_text())
return {key: identity[key] for key in ('agent_id', 'asset_id')}
require(payload['action'] == 'bind', 'unknown bootstrap action')
require(subprocess.run(['systemctl', 'is-active', unit], capture_output=True).stdout.strip() == b'inactive', 'stop owned client before binding')
path = state/'binding.json'
fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW, 0o600)
with os.fdopen(fd, 'w') as stream:
json.dump(payload['binding'], stream)
os.chown(path, account.pw_uid, account.pw_gid)
env = config/'agent.env'
require(env.read_text() == payload['old_environment'], 'bootstrap configuration changed')
env.write_text(payload['environment']); env.chmod(0o600)
(state/'enroll.token').unlink()
return dict(bound=True)
def main():
parser = argparse.ArgumentParser(description=__doc__)
group = parser.add_mutually_exclusive_group(required=True)
group.add_argument('--provision-vm', action='store_true')
group.add_argument('--resume-vm', action='store_true', help='Resume own retained bootstrap; no enrollment/token reset')
args = parser.parse_args()
target = 'vm'
def client(payload):
return rpc('linux-vm.conf', vm, payload)
os.umask(0o077)
record = ROOT/('devstate/remote-'+target+'.json')
require(record.exists() if args.resume_vm else not record.exists(), 'bootstrap record state does not match requested mode')
artifact = (ROOT/'devstate/rmm-agent-remote').read_bytes()
material = rpc('server.conf', server, dict(action='material' if args.resume_vm else 'enroll'))
cfg = access.load_config(ROOT/'credentials/server.conf')
endpoint = cfg['address'] + ':443'
environment = ('RMM_SERVER_NAME='+DOMAIN+'\nRMM_CONNECT_ADDR='+endpoint+'\n'
'RMM_ENROLLMENT_TOKEN_FILE=/var/lib/rmm-agent-remote/enroll.token\n')
unit = (ROOT/'deploy/linux/rmm-agent-remote.service').read_text()
if args.resume_vm:
report = json.loads(record.read_text())
require(report['stage'] in ('installed','passive_observed') and report['domain'] == DOMAIN
and report['binary_sha256'] == hashlib.sha256(artifact).hexdigest()
and report['ca_sha256'] == hashlib.sha256(base64.b64decode(material['ca'])).hexdigest(),
'retained bootstrap or trust binding differs; no reset')
else:
installed = client(dict(action='install', binary=base64.b64encode(artifact).decode(),
binary_sha256=hashlib.sha256(artifact).hexdigest(), unit=unit, environment=environment, **material))
report = dict(stage='installed', installed=installed, domain=DOMAIN, unit=UNIT,
binary_sha256=hashlib.sha256(artifact).hexdigest(), ca_sha256=hashlib.sha256(base64.b64decode(material['ca'])).hexdigest())
def save():
record.write_text(json.dumps(report, indent=2)); record.chmod(0o600)
save()
started = False
try:
started = True; client(dict(action='start'))
end = time.monotonic()+100
identity = {}
while time.monotonic() < end:
identity = client(dict(action='identity'))
if identity:
observed = rpc('server.conf', server, dict(action='observe', agent_id=identity['agent_id']))
if observed.get('inventory_received') and observed.get('last_contact_at'):
break
time.sleep(2)
require(identity and observed.get('inventory_received'), 'native enrollment/inventory not observed')
report.update(identity=identity, passive_observation=observed, stage='passive_observed'); save()
client(dict(action='stop')); started = False
binding = {key: observed[key] for key in ('agent_id','asset_id','enrollment_generation','assignment_version')}
binding.update(tenant_id=TENANT, public_key_hex=material['key']['public_key_hex'])
bound_environment = ('RMM_SERVER_NAME='+DOMAIN+'\nRMM_CONNECT_ADDR='+endpoint+'\n'
'RMM_JOB_BINDING_FILE=/var/lib/rmm-agent-remote/binding.json\nRMM_JOB_SIGNING_KEY_BOOTSTRAP=1\n')
client(dict(action='bind', binding=binding, old_environment=environment, environment=bound_environment))
started = True; client(dict(action='start'))
end = time.monotonic()+100
while time.monotonic() < end:
observed = rpc('server.conf', server, dict(action='observe', agent_id=identity['agent_id']))
if observed.get('sync_ready') and not observed.get('restore_blocked'):
break
time.sleep(2)
require(observed.get('sync_ready') and not observed.get('restore_blocked'), 'native signed sync gate not ready')
client(dict(action='enable'))
report.update(stage='signed_sync_ready', sync_observation=observed, jobs_executed=False); save()
print('PASS '+target+' direct domain TLS/mTLS, passive inventory and signed Sync; no RMM job executed')
# The user requested a client against the remote server. Leave this new
# unprivileged client running; old installation remains stopped/intact.
started = False
finally:
if started:
client(dict(action='stop'))
if __name__ == '__main__':
try:
main()
except Exception:
print('CLIENT_BOOTSTRAP_INCOMPLETE; preserve identities and inspect private state')
raise SystemExit(2) from None