254 lines
14 KiB
Python
254 lines
14 KiB
Python
#!/usr/bin/env python3
|
|
"""Bounded real-VM passive acceptance check. No root bootstrap or job execution."""
|
|
import hashlib
|
|
import io
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import re
|
|
import shlex
|
|
import subprocess
|
|
import sys
|
|
import tarfile
|
|
import tempfile
|
|
import time
|
|
|
|
import vm_access_check as access
|
|
|
|
ROOT = access.ROOT
|
|
sys.path.insert(0, str(ROOT / "tests"))
|
|
import local_integration as api
|
|
|
|
|
|
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 remote_python(ssh, target, env, code):
|
|
return execute(ssh + [target, "python3 -"], env=env, input=code.encode())
|
|
|
|
|
|
PREFLIGHT = r'''
|
|
import glob,json,os,platform,socket,subprocess
|
|
agents=0
|
|
for path in glob.glob('/proc/[0-9]*/exe'):
|
|
try:
|
|
if os.path.basename(os.readlink(path))=='rmm-agent': agents+=1
|
|
except OSError: pass
|
|
ports=subprocess.run(['ss','-H','-ltn'],capture_output=True,text=True,check=True).stdout
|
|
occupied=any(line.split()[3].rsplit(':',1)[-1]=='18443' for line in ports.splitlines())
|
|
libs=subprocess.run(['/sbin/ldconfig','-p'],capture_output=True,text=True,check=True).stdout
|
|
print(json.dumps(dict(architecture=platform.machine(),glibc=platform.libc_ver()[1],
|
|
hostname=socket.gethostname(),agents=agents,occupied=occupied,libraries=libs,
|
|
test_directories=len(glob.glob(os.path.expanduser('~/rmm-passive-test.*'))))))
|
|
'''
|
|
|
|
|
|
def main():
|
|
os.umask(0o077)
|
|
config = access.load_config(ROOT / "credentials/linux-vm.conf")
|
|
known = Path.home() / ".ssh/known_hosts"
|
|
address, port = config["address"], config.get("port", "22")
|
|
lookup = address if port == "22" else f"[{address}]:{port}"
|
|
require(known.is_file(), "trusted host key file missing")
|
|
execute(["ssh-keygen", "-F", lookup, "-f", str(known)])
|
|
for path in Path('/proc').glob('[0-9]*/cmdline'):
|
|
try:
|
|
args = path.read_bytes().split(b'\0')
|
|
except OSError:
|
|
continue
|
|
require(not (args[0].split(b'/')[-1] == b'ssh' and
|
|
any(b'18443:127.0.0.1:18443' in x for x in args)),
|
|
"existing reverse tunnel found; refusing competing listener")
|
|
require(api.request('/healthz')[0] == 200, "local trusted TLS health failed")
|
|
with tempfile.TemporaryDirectory(prefix="rmm-vm-", dir=ROOT / "credentials") as private:
|
|
private = Path(private)
|
|
password = private / "password"
|
|
password.write_text(config.get("password", "") + "\n")
|
|
password.chmod(0o600)
|
|
askpass = private / "askpass"
|
|
askpass.write_text('#!/bin/sh\nexec cat "$RMM_SSH_PASSWORD_FILE"\n')
|
|
askpass.chmod(0o700)
|
|
env = dict(os.environ, SSH_ASKPASS=str(askpass), SSH_ASKPASS_REQUIRE="force",
|
|
DISPLAY="rmm-test:0", RMM_SSH_PASSWORD_FILE=str(password))
|
|
ssh = ["ssh", "-F", "/dev/null", "-T", "-p", port,
|
|
"-o", "StrictHostKeyChecking=yes", "-o", f"UserKnownHostsFile={known}",
|
|
"-o", "GlobalKnownHostsFile=/dev/null", "-o", "ConnectTimeout=10",
|
|
"-o", "ConnectionAttempts=1", "-o", "ForwardAgent=no",
|
|
"-o", "NumberOfPasswordPrompts=1", "-o", "LogLevel=ERROR",
|
|
"-o", "PreferredAuthentications=publickey,password"]
|
|
if config.get("ssh_key_path"):
|
|
ssh += ["-i", str(Path(config['ssh_key_path']).expanduser()), "-o", "IdentitiesOnly=yes"]
|
|
target = f"{config['username']}@{address}"
|
|
facts = json.loads(remote_python(ssh, target, env, PREFLIGHT))
|
|
require(facts['architecture'] == 'x86_64', "unsupported VM architecture")
|
|
require(facts['agents'] == 0 and not facts['occupied'], "VM agent or port already occupied; nothing stopped")
|
|
print("PASS existing-process/port preflight; prior private test directory count:", facts['test_directories'])
|
|
artifact = private / "rmm-agent"
|
|
execute(["docker", "compose", "--env-file", str(ROOT / "devstate/.env"),
|
|
"-f", str(ROOT / "deploy/compose.yaml"), "-p", "rust-discovery-dev",
|
|
"cp", "server:/usr/local/bin/rmm-agent", str(artifact)])
|
|
artifact.chmod(0o700)
|
|
elf = artifact.read_bytes()
|
|
require(elf[:6] == b'\x7fELF\x02\x01' and int.from_bytes(elf[18:20], 'little') == 62,
|
|
"agent artifact is not Linux x86-64 ELF")
|
|
versions = execute(["readelf", "--version-info", str(artifact)]).decode()
|
|
required_glibc = max(tuple(map(int, x.split('.'))) for x in re.findall(r'GLIBC_(\d+\.\d+)', versions))
|
|
require(tuple(map(int, facts['glibc'].split('.'))) >= required_glibc, "agent requires newer glibc")
|
|
dynamic = execute(["readelf", "-d", str(artifact)]).decode()
|
|
libraries = re.findall(r'\(NEEDED\).*\[(.*?)\]', dynamic)
|
|
require(libraries and all(re.search(r'^\s*' + re.escape(lib) + r'\s', facts['libraries'], re.M) for lib in libraries),
|
|
"VM runtime library missing")
|
|
print("PASS artifact ELF/glibc/dependency compatibility; required glibc:", '.'.join(map(str, required_glibc)))
|
|
control = str(private / 'control')
|
|
tunnel_log = private / 'ssh.log'
|
|
remote_dir = None
|
|
agent_pid = None
|
|
report = {'artifact_sha256': hashlib.sha256(elf).hexdigest(),
|
|
'architecture': facts['architecture'], 'glibc': facts['glibc']}
|
|
report_dir = ROOT / 'devstate/vm-passive'
|
|
report_dir.mkdir(mode=0o700, exist_ok=True)
|
|
require(not (report_dir / 'active.json').exists(), "previous managed test record exists; inspect before retry")
|
|
with tunnel_log.open('wb') as log:
|
|
tunnel = subprocess.Popen(ssh + ['-M', '-S', control, '-N', '-T',
|
|
'-o', 'ExitOnForwardFailure=yes', '-o', 'ServerAliveInterval=30',
|
|
'-o', 'ServerAliveCountMax=3', '-R', '127.0.0.1:18443:127.0.0.1:18443', target],
|
|
env=env, stdin=subprocess.DEVNULL, stdout=log, stderr=log, start_new_session=True)
|
|
try:
|
|
deadline = time.monotonic() + 15
|
|
while not Path(control).exists():
|
|
require(tunnel.poll() is None, "strict SSH reverse tunnel failed")
|
|
require(time.monotonic() < deadline, "SSH control socket timeout")
|
|
time.sleep(.1)
|
|
connected = ssh + ['-S', control, '-o', 'BatchMode=yes']
|
|
execute(connected + ['-O', 'check', target], env=env)
|
|
listeners = execute(connected + [target, "ss -H -ltn 'sport = :18443'"], env=env).decode()
|
|
endpoints = [line.split()[3] for line in listeners.splitlines()]
|
|
require(endpoints == ['127.0.0.1:18443'], "reverse listener not exclusively IPv4 loopback")
|
|
print("PASS PC-initiated SSH reverse tunnel; VM listener exclusively 127.0.0.1:18443")
|
|
raw_token = api.token(api.A)
|
|
bundle = io.BytesIO()
|
|
with tarfile.open(fileobj=bundle, mode='w') as archive:
|
|
for name, data, mode in [('rmm-agent', elf, 0o700),
|
|
('ca.pem', api.CA.read_bytes(), 0o600), ('enroll.token', raw_token.encode(), 0o600)]:
|
|
info = tarfile.TarInfo(name)
|
|
info.size, info.mode = len(data), mode
|
|
archive.addfile(info, io.BytesIO(data))
|
|
remote_dir = execute(connected + [target,
|
|
'umask 077; d=$(mktemp -d "$HOME/rmm-passive-test.XXXXXXXX") || exit; '
|
|
'tar -xf - -C "$d" || exit; printf "%s" "$d"'], env=env, input=bundle.getvalue()).decode()
|
|
require(remote_dir.startswith('/') and '\n' not in remote_dir, "invalid private deployment path")
|
|
quoted = shlex.quote(remote_dir)
|
|
# The loader verifies symbol versions before any agent main function runs.
|
|
execute(connected + [target, f'/lib64/ld-linux-x86-64.so.2 --list {quoted}/rmm-agent'], env=env)
|
|
print("PASS VM dynamic loader resolved concrete artifact before native agent launch")
|
|
launch = f'''import os,subprocess
|
|
directory={remote_dir!r}
|
|
os.umask(0o077)
|
|
env=dict(os.environ,RMM_AGENT_STATE=directory+'/state',RMM_CA_FILE=directory+'/ca.pem',
|
|
RMM_ENROLLMENT_TOKEN_FILE=directory+'/enroll.token',RMM_CONNECT_ADDR='127.0.0.1:18443')
|
|
with open(directory+'/agent.log','ab') as log:
|
|
process=subprocess.Popen([directory+'/rmm-agent'],cwd=directory,env=env,
|
|
stdin=subprocess.DEVNULL,stdout=log,stderr=log,start_new_session=True)
|
|
print(process.pid)
|
|
'''
|
|
agent_pid = int(remote_python(connected, target, env, launch))
|
|
# Identify only the exact binary in the newly created private directory.
|
|
code = f'''import glob,json,os
|
|
path={remote_dir!r}+'/rmm-agent'
|
|
pids=[]
|
|
for p in glob.glob('/proc/[0-9]*/exe'):
|
|
try:
|
|
if os.readlink(p)==path:pids.append(int(p.split('/')[2]))
|
|
except OSError:pass
|
|
print(json.dumps(pids))
|
|
'''
|
|
pids = json.loads(remote_python(connected, target, env, code))
|
|
require(pids == [agent_pid], "new VM agent process not uniquely identified")
|
|
agent_pid = pids[0]
|
|
report.update(remote_directory=remote_dir, agent_pid=agent_pid, tunnel_pid=tunnel.pid)
|
|
(report_dir / 'active.json').write_text(json.dumps(report))
|
|
identity = None
|
|
observed = None
|
|
contacts = set()
|
|
deadline = time.monotonic() + 100
|
|
viewer = (ROOT / 'devstate/viewer-a.token').read_text().strip()
|
|
while time.monotonic() < deadline:
|
|
if identity is None:
|
|
result = subprocess.run(connected + [target, f'cat {quoted}/state/identity.json'],
|
|
capture_output=True, env=env, timeout=15)
|
|
if result.returncode == 0:
|
|
identity = json.loads(result.stdout)
|
|
if identity:
|
|
status, data = api.request(f'/api/v1/tenants/{api.A}/devices', viewer)
|
|
require(status == 200, "tenant reader failed")
|
|
observed = next((x for x in json.loads(data)['items'] if x['agent_id'] == identity['agent_id']), None)
|
|
if observed and observed['last_contact_at']:
|
|
contacts.add(observed['last_contact_at'])
|
|
if observed and observed['inventory'] and len(contacts) >= 2:
|
|
break
|
|
require(tunnel.poll() is None, "tunnel ended before acceptance")
|
|
time.sleep(2)
|
|
require(observed and observed['inventory'] and len(contacts) >= 2, "real VM inventory/two fresh heartbeats not observed")
|
|
inventory = observed['inventory']
|
|
require(inventory['hostname'] == facts['hostname'] and inventory['architecture'] == 'x86_64'
|
|
and '24.04' in inventory['os'] and inventory['root_available_bytes'] > 0
|
|
and inventory['root_available_inodes'] > 0 and observed['observed_at'] and observed['received_at']
|
|
and observed['presence'] == 'online', "VM inventory evidence invalid")
|
|
viewer_b = (ROOT / 'devstate/viewer-b.token').read_text().strip()
|
|
status, data = api.request(f'/api/v1/tenants/{api.B}/devices', viewer_b)
|
|
require(status == 200 and identity['agent_id'] not in data.decode(), "VM tenant isolation failed")
|
|
execute(connected + [target, f'rm -- {quoted}/enroll.token'], env=env)
|
|
report.update(agent_id=identity['agent_id'], observed_at=observed['observed_at'],
|
|
received_at=observed['received_at'], heartbeat_times=sorted(contacts),
|
|
verified=True, tenant_isolation=True)
|
|
print("PASS actual VM enrollment/mTLS-WSS/inventory, two distinct fresh heartbeats, tenant isolation")
|
|
finally:
|
|
try:
|
|
if remote_dir and agent_pid:
|
|
cleanup = f'''import os,signal,time
|
|
pid={agent_pid}
|
|
expected={remote_dir!r}+'/rmm-agent'
|
|
try:
|
|
if os.readlink('/proc/'+str(pid)+'/exe')==expected: os.kill(pid,signal.SIGTERM)
|
|
except FileNotFoundError:pass
|
|
for _ in range(30):
|
|
try:
|
|
if os.readlink('/proc/'+str(pid)+'/exe')!=expected:break
|
|
except FileNotFoundError:break
|
|
time.sleep(.1)
|
|
else:raise RuntimeError('agent did not stop')
|
|
token={remote_dir!r}+'/enroll.token'
|
|
try:os.unlink(token)
|
|
except FileNotFoundError:pass
|
|
print('stopped')
|
|
'''
|
|
remote_python(ssh + ['-S', control, '-o', 'BatchMode=yes'], target, env, cleanup)
|
|
report['agent_stopped'] = True
|
|
finally:
|
|
tunnel.terminate()
|
|
tunnel.wait(timeout=15)
|
|
report['tunnel_stopped'] = True
|
|
(report_dir / 'result.json').write_text(json.dumps(report, indent=2))
|
|
if report.get('agent_stopped'):
|
|
(report_dir / 'active.json').unlink(missing_ok=True)
|
|
print("PASS bounded test stopped its own agent/tunnel; private PID/path evidence: devstate/vm-passive/result.json")
|
|
|
|
|
|
if __name__ == '__main__':
|
|
try:
|
|
main()
|
|
except RuntimeError as error:
|
|
print("FAILED:", error)
|
|
raise SystemExit(1) from None
|
|
except Exception:
|
|
print("FAILED: VM passive test incomplete; private details withheld; inspect managed state before retry")
|
|
raise SystemExit(1) from None
|