376 lines
42 KiB
Python
376 lines
42 KiB
Python
#!/usr/bin/env python3
|
|
"""Guarded compatible Linux bootstrap, explicitly coordinated separate phases.
|
|
|
|
No job approval, package operation, reenrollment or private-key transfer. This
|
|
controller is prepared source; invoking mutations requires Root coordination.
|
|
"""
|
|
import argparse
|
|
import base64
|
|
import hashlib
|
|
import inspect
|
|
import io
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import shlex
|
|
import subprocess
|
|
import tarfile
|
|
import uuid
|
|
import linux_updater_bootstrap as prerequisite
|
|
import remote_client_bootstrap as transport
|
|
ROOT=Path(__file__).resolve().parents[1]
|
|
BASE=ROOT/'devstate/linux-updater-capability-build/9923a97f-4c8c-4e0a-bbad-4f1d88f0d43a/manifest.json'
|
|
BASE_SHA='a41ad700b4b7527bf911bf00f2745914188760c631af0c3255364c05f1ef4fbc'
|
|
BOOT='45aba743-be1d-4ae5-ba00-139fb9363bfe'
|
|
|
|
def sha(raw):return hashlib.sha256(raw).hexdigest()
|
|
def once(path,raw):
|
|
path.parent.mkdir(mode=0o700,parents=True,exist_ok=True)
|
|
with path.open('xb') as stream:stream.write(raw);stream.flush();os.fsync(stream.fileno())
|
|
path.chmod(0o600)
|
|
def native_rpc(function,payload,config='linux-vm.conf',timeout=80):
|
|
# Same strict credential parser and already-confirmed host as existing tooling.
|
|
cfg=transport.access.load_config(ROOT/'credentials'/config)
|
|
code='import json,os,subprocess\nfrom pathlib import Path\n'+inspect.getsource(transport.require)+'\n'+inspect.getsource(function)+'\ntry:\n print(json.dumps('+function.__name__+'('+repr(payload)+')))\nexcept Exception as error:\n import traceback\n print(json.dumps({"error_class":type(error).__name__,"frames":[{"function":f.name,"line":f.lineno}for f in traceback.extract_tb(error.__traceback__)]}))\n'
|
|
ssh=['ssh','-F','/dev/null','-T','-p',cfg.get('port','22'),'-o','StrictHostKeyChecking=yes','-o','BatchMode=yes','-o','IdentitiesOnly=yes','-o','ForwardAgent=no','-o','ClearAllForwardings=yes','-o','ConnectTimeout=7','-i',str(Path(cfg['ssh_key_path']).expanduser()),cfg['username']+'@'+cfg['address'],'python3 -I -']
|
|
result=subprocess.run(ssh,input=code.encode(),capture_output=True,timeout=timeout)
|
|
if result.returncode:raise RuntimeError('Bootstrap transport failed; no private diagnostics printed')
|
|
value=json.loads(result.stdout)
|
|
if 'error_class'in value:raise RuntimeError('Bootstrap incomplete; retained native intent needs inspection: '+json.dumps(value))
|
|
return value
|
|
|
|
def public_inputs(payload):
|
|
import stat,json,hashlib,os
|
|
from pathlib import Path
|
|
require(payload=={'operation':'linux_compatible_public_inputs_v1'}and os.geteuid()==0,'fixed public inputs')
|
|
result={}
|
|
for name in ('helper-general.json','general-helper-proof.json','helper-full-maintenance.json','full-maintenance-helper-proof.json','helper-signing-key.json'):
|
|
path=Path('/etc/rmm-remote')/name;meta=path.lstat();require(stat.S_ISREG(meta.st_mode)and meta.st_uid==0 and meta.st_nlink==1 and not meta.st_mode&0o022 and meta.st_size<=16384,'protected public input')
|
|
raw=path.read_bytes();require(path.lstat().st_ino==meta.st_ino and path.lstat().st_mtime_ns==meta.st_mtime_ns,'public input changed');result[name]={'bytes':list(raw),'sha256':hashlib.sha256(raw).hexdigest()}
|
|
general=json.loads(bytes(result['helper-general.json']['bytes']));pin=json.loads(bytes(result['general-helper-proof.json']['bytes']))
|
|
require(general['profile']=='general'and general.get('helper_binary_sha256')is None and pin['schema_version']==1 and pin['profile']=='general'and pin.get('helper_binary_sha256')is None,'exact non-binary General identity/policy profile')
|
|
return result
|
|
|
|
def central_closed(payload):
|
|
import json,subprocess,datetime,uuid,hashlib
|
|
from pathlib import Path
|
|
agent=str(uuid.UUID(payload['agent_id']));tenant=str(uuid.UUID(payload['tenant_id']))
|
|
def run(a):return subprocess.check_output(a,text=True,stderr=subprocess.DEVNULL,timeout=15)
|
|
flags={}
|
|
for role in ('api','gateway'):
|
|
container=json.loads(run(['docker','inspect','rust-discovery-server-'+role+'-1']))[0];env=dict(row.split('=',1)for row in container['Config']['Env']);flag=env.get('RMM_DEV_ROOT_ENABLED','false')
|
|
require(flag in ('true','false'),'known Root gate')
|
|
expired=False
|
|
if flag=='true':
|
|
path=env.get('RMM_DEV_ROOT_POLICY_FILE');require(path=='/root-policy/policy.json','fixed public Root policy')
|
|
mount=next(m for m in container['Mounts']if m['Destination']=='/root-policy');require(mount['RW']is False,'readonly protected policy')
|
|
doc=json.loads((Path(mount['Source'])/'policy.json').read_text());expiry=datetime.datetime.fromisoformat(doc['expires_at'].replace('Z','+00:00'));require(expiry.tzinfo is not None,'absolute policy expiry');expired=expiry<=datetime.datetime.now(datetime.timezone.utc)
|
|
require(flag=='false'or expired,'central Root scope must be closed before compatible bootstrap')
|
|
require('RMM_AGENT_UPDATE_POLICY_FILE'not in env,'initial updater scope must remain absent')
|
|
flags[role]={'root_enabled':flag=='true','root_policy_expired':expired,'container_id':container['Id']}
|
|
query="BEGIN READ ONLY; SELECT count(*) FROM jobs WHERE tenant_id='"+tenant+"' AND agent_id='"+agent+"' AND state NOT IN ('succeeded','failed','cancelled','expired'); COMMIT;"
|
|
rows=run(['docker','exec','rust-discovery-server-postgres-1','psql','-XqAt','-v','ON_ERROR_STOP=1','-U','postgres','-d','rmm','-c',query]).splitlines();require(rows==['0'],'no open or unknown Linux job')
|
|
return {'operation':'linux_compatible_closed_scope_v1','tenant_id':tenant,'agent_id':agent,'observed_at':datetime.datetime.now(datetime.timezone.utc).isoformat(),'roles':flags,'open_jobs':0,'job_authority':False}
|
|
|
|
def passive_check(payload):
|
|
import datetime,json,subprocess,uuid
|
|
tenant=str(uuid.UUID(payload['tenant_id']));agent=str(uuid.UUID(payload['agent_id']))
|
|
query="BEGIN READ ONLY; SELECT json_build_object('connection_generation',i.connection_generation,'capabilities',i.capabilities,'last_contact_at',i.last_contact_at,'observed_at',o.observed_at,'received_at',o.received_at,'data',o.data,'payload_sha256',o.payload_sha256) FROM agent_installations i JOIN LATERAL (SELECT * FROM observations WHERE tenant_id=i.tenant_id AND agent_id=i.agent_id AND source_id='agent.update' ORDER BY sequence DESC LIMIT 1)o ON true WHERE i.tenant_id='"+tenant+"' AND i.agent_id='"+agent+"' AND i.revoked_at IS NULL; COMMIT;"
|
|
output=subprocess.check_output(['docker','exec','rust-discovery-server-postgres-1','psql','-XqAt','-v','ON_ERROR_STOP=1','-U','postgres','-d','rmm','-c',query],stderr=subprocess.DEVNULL,text=True,timeout=15).splitlines();require(len(output)==1,'one actual current installation/passive observation')
|
|
observed=json.loads(output[0]);sample=observed['data']['agent_update'];now=datetime.datetime.now(datetime.timezone.utc)
|
|
for text in (observed['last_contact_at'],observed['received_at'],sample['observed_at']):
|
|
age=(now-datetime.datetime.fromisoformat(text.replace('Z','+00:00'))).total_seconds();require(0<=age<90,'fresh actual persisted passive evidence')
|
|
require(sample['quality']=='valid'and sample['platform']=='x86_64-unknown-linux-gnu'and sample['activation_floor']==1 and not sample['rolled_back']and sample['helper_observation_sha256']and sample['signed_sync_decision_id'],'actual Full verified passive baseline')
|
|
require(sample['predecessor']['installed_record_sha256']==payload['record_sha256']and sample['predecessor']['agent_sha256']==payload['agent_sha256']and sample['predecessor']['helper_sha256']==payload['helper_sha256'],'actual current predecessor')
|
|
require(sample['updater']['binary_sha256']==payload['updater_sha256']and sample['updater']['policy_sha256']==payload['policy_sha256']and sample['updater']['keyring_sha256']==payload['keyring_sha256']and sample['updater']['health_key_pin_sha256']==payload['health_pin_sha256'],'actual protected updater trust bindings')
|
|
required=['agent.update.apply/1','agent.update.check/1','update_agent','root:update_agent','helper.root.v1','rmm.sync.v1','helper.binary.sha256:'+payload['helper_sha256'],'helper.policy.sha256:'+payload['helper_policy_sha256'],'updater.binary.sha256:'+payload['updater_sha256'],'updater.policy.sha256:'+payload['policy_sha256']]
|
|
require(all(cap in observed['capabilities']for cap in required),'actual current qualified runtime capabilities, no SQL override')
|
|
return {'operation':'linux_compatible_passive_qualification_v1','tenant_id':tenant,'agent_id':agent,'sample':sample,'connection_generation':observed['connection_generation'],'capabilities':observed['capabilities'],'observation_payload_sha256':observed['payload_sha256'],'actual_passive_path':True,'database_written':False,'job_authority':False}
|
|
|
|
def stage(payload):
|
|
import base64,hashlib,json,os,stat,uuid
|
|
from pathlib import Path
|
|
require(os.geteuid()==0 and os.uname().machine=='x86_64','root x86 Linux only')
|
|
ident=str(uuid.UUID(payload['case_id']));base=Path('/var/lib/rmm-updater-bootstrap')
|
|
if not base.exists():base.mkdir(mode=0o700)
|
|
meta=base.lstat();require(stat.S_ISDIR(meta.st_mode)and meta.st_uid==0 and stat.S_IMODE(meta.st_mode)==0o700,'protected bootstrap root')
|
|
folder=base/ident;folder.mkdir(mode=0o700)
|
|
files=payload['files'];require(set(files)=={'agent.bin','helper.bin','updater.bin','sdk.bin','full-config.json','full-pin.json','updater.service'},'closed bootstrap artifact set')
|
|
for name,entry in files.items():
|
|
raw=base64.b64decode(entry['base64'],validate=True);require(len(raw)==entry['bytes']and hashlib.sha256(raw).hexdigest()==entry['sha256'],'exact public artifact')
|
|
if name.endswith('.bin'):require(raw[:6]==b'\x7fELF\x02\x01'and raw[18:20]==b'\x3e\x00','Linux x86-64 ELF')
|
|
fd=os.open(folder/name,os.O_WRONLY|os.O_CREAT|os.O_EXCL|os.O_NOFOLLOW,0o500 if name.endswith('.bin') else 0o600)
|
|
with os.fdopen(fd,'wb')as stream:stream.write(raw);stream.flush();os.fsync(stream.fileno())
|
|
manifest={k:v for k,v in payload.items()if k!='files'};manifest['files']={n:{k:v for k,v in e.items()if k!='base64'}for n,e in files.items()}
|
|
with(folder/'manifest.json').open('x')as stream:json.dump(manifest,stream,sort_keys=True);stream.flush();os.fsync(stream.fileno())
|
|
return {'case_id':ident,'folder':str(folder),'staged':True,'services_changed':False,'job_authority':False}
|
|
|
|
def pair(payload):
|
|
import base64,contextlib,fcntl,hashlib,json,os,select,sqlite3,stat,subprocess,time,uuid,datetime
|
|
from pathlib import Path
|
|
require(os.geteuid()==0 and os.uname().machine=='x86_64','root x86 Linux only')
|
|
ident=str(uuid.UUID(payload['case_id']));folder=Path('/var/lib/rmm-updater-bootstrap')/ident;manifest=json.loads((folder/'manifest.json').read_text())
|
|
require(Path('/proc/sys/kernel/random/boot_id').read_text().strip()==manifest['boot_id'],'original boot')
|
|
def sha(raw):return hashlib.sha256(raw).hexdigest()
|
|
def run(a,timeout=20):return subprocess.check_output(a,text=True,stderr=subprocess.DEVNULL,timeout=timeout).strip()
|
|
def syncdir(path):
|
|
fd=os.open(path,os.O_RDONLY|os.O_DIRECTORY)
|
|
try:os.fsync(fd)
|
|
finally:os.close(fd)
|
|
def record(name,value):
|
|
with(folder/name).open('x')as stream:json.dump(value,stream,sort_keys=True);stream.flush();os.fsync(stream.fileno())
|
|
syncdir(folder)
|
|
def public(path,maximum):
|
|
path=Path(path);meta=path.lstat();require(stat.S_ISREG(meta.st_mode)and meta.st_uid==0 and meta.st_nlink==1 and not meta.st_mode&0o022 and meta.st_size<=maximum,'protected original public file');return path.read_bytes(),meta
|
|
def identity(path):
|
|
m=Path(path).lstat();require(not stat.S_ISLNK(m.st_mode),'no substituted path');return [m.st_dev,m.st_ino,m.st_uid,m.st_gid,m.st_mode,m.st_nlink]
|
|
def status(unit):
|
|
fields={k:v for k,v in(line.split('=',1)for line in run(['systemctl','show','--all','--property=Id,ActiveState,SubState,MainPID,ControlPID,InvocationID,Job,ControlGroup,UnitFileState','--',unit]).splitlines())};require(fields['Id']==unit,'exact service');return fields
|
|
units=['rmm-agent-remote.service','rmm-helper-cloud.service','rmm-full-maintenance-helper.service']
|
|
def databases():
|
|
result={}
|
|
for path in ('/var/lib/rmm-agent-remote/journal.sqlite','/var/lib/rmm-agent-remote/consumption.sqlite','/var/lib/rmm-helper/consumption.sqlite'):
|
|
require(not Path(path+'-wal').exists()and not Path(path+'-shm').exists(),'existing DELETE journals')
|
|
with contextlib.closing(sqlite3.connect('file:'+path+'?mode=ro',uri=True,timeout=.5))as db:
|
|
db.execute('PRAGMA query_only=ON');require(db.execute('PRAGMA integrity_check').fetchone()[0]=='ok','original journal integrity')
|
|
tables={r[0]for r in db.execute("SELECT name FROM sqlite_master WHERE type='table'")};evidence=[]
|
|
if 'consumed'in tables:
|
|
require(db.execute('SELECT count(*) FROM consumed WHERE result IS NULL').fetchone()[0]==0,'no unresolved original effect')
|
|
for row in db.execute('SELECT c.grant_id,c.agent,c.generation,c.job,c.attempt,c.result,e.start,e.outcome FROM consumed c LEFT JOIN execution_evidence e USING(grant_id) ORDER BY c.grant_id'):
|
|
evidence.append([v if isinstance(v,(str,int))or v is None else sha(v)for v in row])
|
|
if 'job_attempts'in tables:require(db.execute("SELECT count(*) FROM job_attempts WHERE state NOT IN ('succeeded','failed','cancelled','expired')").fetchone()[0]==0,'no open original agent job')
|
|
for name in ('helper_sync_meta','reconcile_meta'):
|
|
if name in tables:require(db.execute('SELECT count(*) FROM '+name+' WHERE fault IS NOT NULL').fetchone()[0]==0,'no original journal fault')
|
|
generation=db.execute('SELECT generation FROM reconcile_meta WHERE id=1').fetchone()[0]if 'reconcile_meta'in tables else None
|
|
result[path]={'file_id':identity(path),'evidence_sha256':sha(json.dumps(evidence,separators=(',',':')).encode()),'consumptions':len(evidence),'generation':generation}
|
|
return result
|
|
def retained_metadata():
|
|
result={}
|
|
fixed=['/var/lib/rmm-agent-remote/binding.json','/var/lib/rmm-agent-remote/identity.json','/var/lib/rmm-agent-remote/job-signing-key.json','/var/lib/rmm-agent-remote/device.key','/var/lib/rmm-agent-remote/device.pem','/etc/rmm-remote/agent.env','/etc/rmm-remote/helper-general.json','/etc/rmm-remote/general-helper-proof.json','/etc/rmm-remote/helper-signing-key.json']
|
|
cert=Path('/var/lib/rmm-agent-remote/certificates')
|
|
if cert.exists():fixed.extend(str(p)for p in cert.rglob('*')if p.is_file())
|
|
for path in fixed:
|
|
m=Path(path).lstat();require(stat.S_ISREG(m.st_mode)and m.st_nlink==1,'retained original metadata');result[path]=identity(path)+[m.st_size,m.st_mtime_ns,m.st_ctime_ns]
|
|
return result
|
|
for name,entry in manifest['files'].items():require(sha((folder/name).read_bytes())==entry['sha256'],'staged artifact changed')
|
|
for unit in ('rmm-apt-helper.service','rmm-agent.service','rmm-helper-dev-test.service'):
|
|
s=status(unit);require(s['ActiveState']=='inactive'and s['MainPID']in('','0')and s['ControlPID']in('','0')and s['Job']==''and s['UnitFileState']in('','disabled'),'APT and legacy remain closed')
|
|
if payload['action']=='install':
|
|
require(not(folder/'pair-install-intent.json').exists(),'existing intent means readback, never repeat')
|
|
fence=payload['central_fence'];require(fence['operation']=='linux_compatible_closed_scope_v1'and fence['open_jobs']==0 and not fence['job_authority']and fence['tenant_id']==manifest['tenant_id']and fence['agent_id']==manifest['agent_id'],'closed central scope')
|
|
at=datetime.datetime.fromisoformat(fence['observed_at']);require(0<=(datetime.datetime.now(datetime.timezone.utc)-at).total_seconds()<30,'fresh closed-scope readback')
|
|
before={u:status(u)for u in units};pids=[]
|
|
for u,s in before.items():
|
|
require(s['ActiveState']=='active'and int(s['MainPID'])>1 and s['ControlPID']=='0'and s['Job']=='','exact active original pair')
|
|
pid=int(s['MainPID']);fd=os.pidfd_open(pid);pids.append(fd)
|
|
original=databases();retained=retained_metadata()
|
|
for source,target,oldsha in [('agent.bin','/usr/local/libexec/rmm-agent-remote',manifest['old_agent_sha256']),('helper.bin','/usr/local/libexec/rmm-privileged-helper',manifest['old_helper_sha256']),('full-config.json','/etc/rmm-remote/helper-full-maintenance.json',manifest['old_config_sha256']),('full-pin.json','/etc/rmm-remote/full-maintenance-helper-proof.json',manifest['old_pin_sha256'])]:
|
|
raw,_=public(target,256*1024*1024);require(sha(raw)==oldsha,'original target CAS')
|
|
record('pair-install-intent.json',{'before':before,'databases':original,'retained':retained,'central_fence':fence,'files':manifest['files']})
|
|
run(['systemctl','stop','--',units[0],units[2],units[1]],30)
|
|
for fd in pids:
|
|
poll=select.poll();poll.register(fd,select.POLLIN);require(poll.poll(1000),'original process not exited');os.close(fd)
|
|
for u in units:
|
|
s=status(u);require(s['ActiveState']=='inactive'and s['MainPID']=='0'and s['ControlPID']=='0'and not s['Job']and not s['ControlGroup'],'all original processes stopped')
|
|
with contextlib.ExitStack()as held:
|
|
for path in ('/var/lib/rmm-agent-remote/agent.lock','/var/lib/rmm-helper/executor.lock'):
|
|
f=held.enter_context(open(path,'rb'));fcntl.flock(f,fcntl.LOCK_EX|fcntl.LOCK_NB)
|
|
closed=databases()
|
|
require(all(closed[p]['file_id']==v['file_id']and closed[p]['evidence_sha256']==v['evidence_sha256']for p,v in original.items()),'original effect history changed during stop')
|
|
for source,target,oldsha in [('agent.bin','/usr/local/libexec/rmm-agent-remote',manifest['old_agent_sha256']),('helper.bin','/usr/local/libexec/rmm-privileged-helper',manifest['old_helper_sha256']),('full-config.json','/etc/rmm-remote/helper-full-maintenance.json',manifest['old_config_sha256']),('full-pin.json','/etc/rmm-remote/full-maintenance-helper-proof.json',manifest['old_pin_sha256'])]:
|
|
target=Path(target);old,meta=public(target,256*1024*1024);require(sha(old)==oldsha,'stopped target CAS')
|
|
previous=target.with_name(target.name+'.bootstrap-'+ident+'.previous');candidate=target.with_name(target.name+'.bootstrap-'+ident+'.candidate');require(not previous.exists()and not candidate.exists(),'create-once bootstrap names')
|
|
fd=os.open(candidate,os.O_WRONLY|os.O_CREAT|os.O_EXCL|os.O_NOFOLLOW,stat.S_IMODE(meta.st_mode))
|
|
with os.fdopen(fd,'wb')as stream:os.fchown(stream.fileno(),meta.st_uid,meta.st_gid);stream.write((folder/source).read_bytes());stream.flush();os.fsync(stream.fileno())
|
|
record(source+'-save-intent.json',{'target':str(target),'previous':str(previous),'old_sha256':oldsha});os.rename(target,previous);syncdir(target.parent)
|
|
record(source+'-publish-intent.json',{'candidate':str(candidate),'target':str(target),'sha256':manifest['files'][source]['sha256']});os.rename(candidate,target);syncdir(target.parent)
|
|
syncdir(target.parent)
|
|
require(sha(target.read_bytes())==manifest['files'][source]['sha256']and sha(previous.read_bytes())==oldsha,'exact predecessor and replacement retained')
|
|
require(retained_metadata()==retained,'original key identity General policy or PKI changed')
|
|
record('pair-installed.json',{'databases':closed,'retained':retained,'old_generation':original['/var/lib/rmm-agent-remote/journal.sqlite']['generation'],'services_stopped':True,'job_authority':False})
|
|
return {'case_id':ident,'compatible_files_installed':True,'services_stopped':True,'next':'separate reviewed unit setup and start phase','job_authority':False}
|
|
elif payload['action']=='units':
|
|
installed=json.loads((folder/'pair-installed.json').read_text());require(not(folder/'unit-install-intent.json').exists(),'existing unit intent means readback only')
|
|
require(retained_metadata()==installed['retained'],'original metadata changed')
|
|
for u in units:
|
|
row=status(u);require(row['ActiveState']=='inactive'and row['MainPID']=='0'and row['ControlPID']=='0'and not row['Job'],'pair remains stopped before unit setup')
|
|
paths={'/usr/local/libexec/rmm-agent-updater':('updater.bin',0o755),'/etc/systemd/system/rmm-agent-updater.service':('updater.service',0o644)}
|
|
require(all(not Path(path).exists()for path in paths),'stable updater is create-only')
|
|
require(not Path('/etc/rmm-agent-updater').exists()and not Path('/var/lib/rmm-agent-updater').exists(),'initial trust namespace only')
|
|
override=Path('/etc/systemd/system/rmm-full-maintenance-helper.service.d/99-rmm-update-closed-start.conf');require(not override.exists(),'create-only closed restart override')
|
|
record('unit-install-intent.json',{'paths':list(paths),'override':str(override),'restart':'no','services_started':False})
|
|
for path,(name,mode)in paths.items():
|
|
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((folder/name).read_bytes());stream.flush();os.fsync(stream.fileno())
|
|
if not override.parent.exists():override.parent.mkdir(mode=0o755)
|
|
require(override.parent.lstat().st_uid==0 and not override.parent.is_symlink()and not override.parent.lstat().st_mode&0o022,'protected Full override parent')
|
|
with override.open('xb')as stream:stream.write(b'[Service]\nRestart=no\n');stream.flush();os.fsync(stream.fileno())
|
|
override.chmod(0o644)
|
|
for path,mode in [('/etc/rmm-agent-updater',0o755),('/var/lib/rmm-agent-updater',0o700),('/var/lib/rmm-agent-updater/records',0o700),('/var/lib/rmm-agent-updater/handoffs',0o700)]:Path(path).mkdir(mode=mode)
|
|
binding=json.loads(Path('/var/lib/rmm-agent-remote/binding.json').read_text());key=json.loads(Path('/etc/rmm-remote/helper-signing-key.json').read_text())
|
|
require(binding.get('public_key_hex')in('',key['public_key_hex']),'independent effective public key pin');binding['public_key_hex']=key['public_key_hex']
|
|
fd=os.open('/etc/rmm-agent-updater/binding.json',os.O_WRONLY|os.O_CREAT|os.O_EXCL|os.O_NOFOLLOW,0o600)
|
|
with os.fdopen(fd,'w')as stream:json.dump(binding,stream,separators=(',',':'));stream.flush();os.fsync(stream.fileno())
|
|
run(['systemctl','daemon-reload'])
|
|
require(run(['systemctl','show','--value','--property=Restart','--',units[2]])=='no','actual closed Full restart contract')
|
|
updater=status('rmm-agent-updater.service');require(updater['ActiveState']=='inactive'and updater['MainPID']=='0'and updater['ControlPID']=='0'and not updater['Job']and updater['UnitFileState']=='disabled','updater remains stopped and disabled')
|
|
record('units-installed.json',{'updater':updater,'restart_override_sha256':sha(override.read_bytes()),'namespace_provisioned':True,'updater_started':False})
|
|
return {'case_id':ident,'updater_unit_installed_not_started':True,'full_restart_no_bound':True,'job_authority':False}
|
|
elif payload['action']=='start':
|
|
installed=json.loads((folder/'pair-installed.json').read_text());require((folder/'units-installed.json').is_file(),'separate reviewed unit setup required');require(not(folder/'pair-start-intent.json').exists(),'existing start means readback only')
|
|
require(retained_metadata()==installed['retained'],'original metadata changed')
|
|
for u in units:
|
|
s=status(u);require(s['ActiveState']=='inactive'and s['MainPID']=='0'and s['ControlPID']=='0'and not s['Job'],'pair remains stopped')
|
|
record('pair-start-intent.json',{'units':[units[1],units[2],units[0]],'only_once':True})
|
|
for u in (units[1],units[2],units[0]):
|
|
record(u+'-start-intent.json',{'unit':u});run(['systemctl','start','--',u],20);s=status(u);require(s['ActiveState']=='active'and int(s['MainPID'])>1,'single compatible start')
|
|
record('pair-started.json',{'status':{u:status(u)for u in units},'job_authority':False})
|
|
return {'case_id':ident,'compatible_services_started_once':True,'job_authority':False,'normal_signed_sync_qualification_still_required':True}
|
|
elif payload['action']=='qualify':
|
|
installed=json.loads((folder/'pair-installed.json').read_text());require((folder/'pair-started.json').is_file(),'compatible starts required')
|
|
def pin(unit):
|
|
raw=run(['systemctl','show','--all','--property=FragmentPath,DropInPaths','--',unit]);fields=dict(line.split('=',1)for line in raw.splitlines());paths=[fields['FragmentPath']]+fields['DropInPaths'].split();require(bool(paths[0]),'actual unit composition')
|
|
composition=[]
|
|
for path in paths:
|
|
data,m=public(path,65536);composition.append([path,{'identity':dict(zip(('device','inode','uid','gid','mode','links'),identity(path))),'bytes':len(data),'sha256':sha(data)}])
|
|
return {'unit':unit,'unit_sha256':sha(json.dumps(composition,separators=(',',':'),ensure_ascii=False).encode())}
|
|
pins=[pin(u)for u in units]
|
|
if run(['systemctl','show','--value','--property=LoadState','--','rmm-apt-helper.service'])=='loaded':pins.append(pin('rmm-apt-helper.service'))
|
|
request={'operation':'qualify_pair','minimum_generation':installed['old_generation'],'expected_agent_sha256':manifest['files']['agent.bin']['sha256'],'expected_helper_sha256':manifest['files']['helper.bin']['sha256'],'unit_pins':pins}
|
|
raw=subprocess.check_output([str(folder/'sdk.bin')],input=json.dumps(request).encode(),stderr=subprocess.DEVNULL,timeout=35);value=json.loads(raw)
|
|
require(value['profile']=='linux_compatible_baseline_qualification_v1'and value['normal_signed_sync_observed']and value['ready']is False and value['helper_ready']is False and value['unlock']is False and value['job_authority']is False,'actual fresh normal qualification')
|
|
after=databases();require(all(after[p]['file_id']==v['file_id']and after[p]['evidence_sha256']==v['evidence_sha256']for p,v in installed['databases'].items()),'all original consumption and evidence retained')
|
|
require(retained_metadata()==installed['retained'],'original General identity key or PKI changed')
|
|
with(folder/'qualification.json').open('xb')as stream:stream.write(raw);stream.flush();os.fsync(stream.fileno())
|
|
record('pair-qualified.json',{'qualification_sha256':sha(raw),'unit_pins':pins,'databases':after,'job_authority':False})
|
|
return {'case_id':ident,'qualification_sha256':sha(raw),'qualification_base64url':base64.urlsafe_b64encode(raw).rstrip(b'=').decode(),'sample':value,'services_restarted':False,'job_authority':False}
|
|
elif payload['action']=='registry':
|
|
receipt=json.loads((folder/'pair-qualified.json').read_text());raw=(folder/'qualification.json').read_bytes();require(sha(raw)==receipt['qualification_sha256'],'actual qualification bytes unchanged')
|
|
require(not(folder/'registry.json').exists(),'create-only actual registry')
|
|
request={'operation':'registry','qualification_sha256':receipt['qualification_sha256']}
|
|
output=subprocess.check_output([str(folder/'sdk.bin')],input=json.dumps(request).encode(),stderr=subprocess.DEVNULL,timeout=35);value=json.loads(output)
|
|
registry=bytes(value['registry_bytes']);require(sha(registry)==value['reader_registry_sha256'],'actual typed registry hash')
|
|
with(folder/'registry.json').open('xb')as stream:stream.write(registry);stream.flush();os.fsync(stream.fileno())
|
|
record('registry-prepared.json',value)
|
|
return {'case_id':ident,'registry':value,'services_changed':False,'job_authority':False}
|
|
elif payload['action']=='trust':
|
|
import tempfile
|
|
trust=payload['trust'];require(trust['operation']=='linux_compatible_trust_install_v1'and trust['case_id']==ident and trust['job_authority']is False,'fixed public trust package')
|
|
receipt=json.loads((folder/'pair-qualified.json').read_text());require(trust['qualification_sha256']==receipt['qualification_sha256'],'original native qualification')
|
|
require(not(folder/'trust-install-intent.json').exists(),'existing trust intent means readback only')
|
|
expected={'policy.json','keyring.json','health-key.json','reader-registry.json','installed-record.json'};require(set(trust['files'])==expected,'closed trust document set')
|
|
raw={}
|
|
for name,entry in trust['files'].items():
|
|
raw[name]=base64.b64decode(entry['base64'],validate=True);require(len(raw[name])==entry['bytes']and len(raw[name])<=65536 and sha(raw[name])==entry['sha256'],'exact bounded public trust bytes')
|
|
require(raw['reader-registry.json']==(folder/'registry.json').read_bytes(),'actual measured reader registry')
|
|
request={'operation':'validate_public_bundle','record':list(raw['installed-record.json']),'policy':list(raw['policy.json']),'keyring':list(raw['keyring.json']),'health_pin':list(raw['health-key.json'])}
|
|
checked=json.loads(subprocess.check_output([str(folder/'sdk.bin')],input=json.dumps(request).encode(),stderr=subprocess.DEVNULL,timeout=20));require(checked==trust['shape_checks']and checked['shape_only_not_signature_verified']is True,'independent native typed shape check')
|
|
policy=json.loads(raw['policy.json']);keys=json.loads(raw['keyring.json']);health=json.loads(raw['health-key.json']);baseline=policy['initial_baseline'];record_doc=json.loads(raw['installed-record.json']);envelope=record_doc['release_envelope']
|
|
require(keys['generation']==1 and len(keys['keys'])==1 and keys['keys'][0]['platform']=='x86_64-unknown-linux-gnu'and keys['keys'][0]['first_sequence']==1 and keys['keys'][0]['last_sequence']==2 and not keys['keys'][0]['revoked'],'initial two-release trust scope')
|
|
public_key=bytes.fromhex(keys['keys'][0]['public_key_hex']);job_key=json.loads(Path('/etc/rmm-remote/helper-signing-key.json').read_text())['public_key_hex'];require(len(public_key)==32 and public_key.hex()!=job_key and public_key.hex()!=health['public_key_hex']and health['public_key_hex']!=job_key,'separate updater release health and Job keys')
|
|
require(sha(public_key)==baseline['key_id']==envelope['key_id'],'exact independently provisioned release key identity')
|
|
def decode(value):
|
|
decoded=base64.urlsafe_b64decode(value+'='*((-len(value))%4));require(base64.urlsafe_b64encode(decoded).rstrip(b'=').decode()==value,'canonical signed public bytes');return decoded
|
|
with tempfile.TemporaryDirectory(prefix='rmm-bootstrap-verify-')as tmp:
|
|
temp=Path(tmp);(temp/'public.der').write_bytes(bytes.fromhex('302a300506032b6570032100')+public_key)
|
|
for role,document,prefix in [('baseline',baseline,b'rmm.agent-update-baseline.v1\0'),('release',envelope,b'rmm.agent-release.v1\0')]:
|
|
message=decode(document['payload_bytes']);signature=decode(document['signature']);require(len(signature)==64,'original Ed25519 signature')
|
|
(temp/'message').write_bytes(prefix+message);(temp/'signature').write_bytes(signature)
|
|
subprocess.run(['openssl','pkeyutl','-verify','-rawin','-pubin','-keyform','DER','-inkey',str(temp/'public.der'),'-in',str(temp/'message'),'-sigfile',str(temp/'signature')],check=True,stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL,timeout=10)
|
|
if role=='baseline':require(message==raw['installed-record.json'],'exact initial signed record')
|
|
else:
|
|
release=json.loads(message);require(sha(message)==record_doc['manifest_sha256']and release['release_sequence']==1 and release['version']=='0.1.0'and release['platform']=='x86_64-unknown-linux-gnu','exact initial signed manifest')
|
|
require([(a['role'],a['sha256'],a['bytes'])for a in release['artifacts']]==[(role,manifest['files'][name]['sha256'],manifest['files'][name]['bytes'])for role,name in [('agent','agent.bin'),('helper','helper.bin')]],'signed release binds exact installed compatible code pair')
|
|
require(record_doc['activation_evidence']=={'kind':'bootstrap','qualification_receipt_sha256':receipt['qualification_sha256']}and policy['updater_binary_sha256']==manifest['files']['updater.bin']['sha256'],'actual qualification and stable updater')
|
|
require(all(policy[k]==manifest[k]for k in ('tenant_id','asset_id','agent_id','enrollment_generation','assignment_version'))and policy['services']==json.loads((folder/'registry-prepared.json').read_text())['services'],'exact local identity and actual unit pins')
|
|
retained=retained_metadata();specs=[]
|
|
mutable={'/var/lib/rmm-agent-remote/journal.sqlite','/var/lib/rmm-agent-remote/consumption.sqlite','/var/lib/rmm-helper/consumption.sqlite'}
|
|
paths=sorted(set(retained)|mutable|{'/var/lib/rmm-agent-remote/agent.lock','/var/lib/rmm-helper/executor.lock'})
|
|
for path in paths:
|
|
m=Path(path).lstat();require(stat.S_ISREG(m.st_mode)and not Path(path).is_symlink(),'retained state original regular file');parent=Path(path).parent.lstat();owner=993 if path.startswith('/var/lib/rmm-agent-remote/')else 0;require(parent.st_uid==owner and not parent.st_mode&0o022,'retained state protected parent')
|
|
specs.append({'path':path,'parent_uid':owner,'identity':dict(zip(('device','inode','uid','gid','mode','links'),identity(path))),'retention':'mutable_database'if path in mutable else'immutable_metadata'})
|
|
require(0<len(specs)<=64,'bounded retained metadata set');raw['retained-files.json']=json.dumps(specs,separators=(',',':')).encode()
|
|
targets={name:Path('/var/lib/rmm-agent-updater/installed-record.json')if name=='installed-record.json'else Path('/etc/rmm-agent-updater')/name for name in raw}
|
|
require(all(not p.exists()for p in targets.values()),'create-only trust installation')
|
|
updater=status('rmm-agent-updater.service');require(updater['ActiveState']=='inactive'and updater['MainPID']=='0'and updater['ControlPID']=='0'and not updater['Job'],'updater remains stopped before trust')
|
|
record('trust-install-intent.json',{'files':{n:sha(b)for n,b in raw.items()},'qualification_sha256':receipt['qualification_sha256'],'public_signatures_verified':True,'updater_started':False})
|
|
for name,data in raw.items():
|
|
target=targets[name];mode=0o600 if name=='installed-record.json'else 0o644;fd=os.open(target,os.O_WRONLY|os.O_CREAT|os.O_EXCL|os.O_NOFOLLOW,mode)
|
|
with os.fdopen(fd,'wb')as stream:stream.write(data);stream.flush();os.fsync(stream.fileno())
|
|
os.chmod(target,mode);syncdir(target.parent)
|
|
require(retained_metadata()==retained,'original identity metadata retained through public trust install')
|
|
record('trust-installed.json',{'files':{n:sha(b)for n,b in raw.items()},'public_signatures_verified':True,'job_authority':False})
|
|
return {'case_id':ident,'protected_trust_installed':True,'release_and_baseline_signatures_verified':True,'updater_started':False,'job_authority':False}
|
|
elif payload['action']=='updater-start':
|
|
trust=json.loads((folder/'trust-installed.json').read_text());require(not(folder/'updater-start-intent.json').exists(),'existing start intent means readback only')
|
|
for name,wanted in trust['files'].items():
|
|
target=Path('/var/lib/rmm-agent-updater/installed-record.json')if name=='installed-record.json'else Path('/etc/rmm-agent-updater')/name;require(sha(target.read_bytes())==wanted,'protected trust unchanged before single start')
|
|
updater=status('rmm-agent-updater.service');require(updater['ActiveState']=='inactive'and updater['MainPID']=='0'and updater['ControlPID']=='0'and not updater['Job'],'fixed stopped updater before start')
|
|
record('updater-start-intent.json',{'unit':'rmm-agent-updater.service','only_once':True,'job_authority':False});run(['systemctl','start','--','rmm-agent-updater.service'],20)
|
|
updater=status('rmm-agent-updater.service');pid=int(updater['MainPID']);require(updater['ActiveState']=='active'and pid>1 and updater['ControlPID']=='0'and not updater['Job'],'actual stable updater started')
|
|
fd=os.pidfd_open(pid)
|
|
try:
|
|
start=Path('/proc/'+str(pid)+'/stat').read_text().rsplit(') ',1)[1].split()[19];image=Path('/proc/'+str(pid)+'/exe').read_bytes();require(sha(image)==manifest['files']['updater.bin']['sha256'],'actual original stable updater image')
|
|
require(status('rmm-agent-updater.service')==updater,'same updater process held through observation')
|
|
finally:os.close(fd)
|
|
record('updater-started.json',{'status':updater,'process_start_ticks':start,'image_sha256':sha(image),'job_authority':False})
|
|
return {'case_id':ident,'stable_updater_started_once':True,'pid':pid,'image_sha256':sha(image),'actual_agent_passive_observation_still_required':True,'job_authority':False}
|
|
elif payload['action']=='readback':
|
|
names=[p.name for p in folder.glob('*')if p.name.endswith('.json')and p.name!='manifest.json'];public={}
|
|
for name in ('qualification.json','registry-prepared.json','pair-qualified.json','trust-installed.json','updater-started.json'):
|
|
path=folder/name
|
|
if path.exists():
|
|
raw=path.read_bytes();require(len(raw)<=192*1024,'bounded public readback');public[name]={'sha256':sha(raw),'base64url':base64.urlsafe_b64encode(raw).rstrip(b'=').decode()}
|
|
return {'case_id':ident,'records':names,'public_evidence':public,'status':{u:status(u)for u in units+['rmm-agent-updater.service']},'databases':databases(),'job_authority':False}
|
|
else:raise RuntimeError('unknown fixed pair action')
|
|
|
|
def prepare(sdk_manifest):
|
|
require=lambda ok,msg:None if ok else(_ for _ in()).throw(RuntimeError(msg))
|
|
require(sha(BASE.read_bytes())==BASE_SHA,'exact capability derivative V2 manifest')
|
|
build=json.loads(BASE.read_text());sdk=json.loads(sdk_manifest.read_text());require(sdk['profile']=='linux_updater_bootstrap_metadata_sdk_v1'and sdk['release_built']and sdk['clippy_all_targets_passed']and not sdk['target_mutated'],'sealed metadata SDK')
|
|
inputs=native_rpc(public_inputs,{'operation':'linux_compatible_public_inputs_v1'})
|
|
snapshot=transport.rpc('linux-vm.conf',prerequisite.inspect_vm,{'operation':'linux_updater_bootstrap_inspect_v1'})
|
|
require(snapshot['boot_id']==BOOT and not snapshot['updater_provisioned'],'original initial target')
|
|
full=json.loads(bytes(inputs['helper-full-maintenance.json']['bytes']));key=json.loads(bytes(inputs['helper-signing-key.json']['bytes']))
|
|
require(full['signing_key_file']=='/etc/rmm-remote/helper-signing-key.json','independent fixed Full keyfile')
|
|
binary=Path(sdk['binary']['path']);require(sha(binary.read_bytes())==sdk['binary']['sha256'],'sealed SDK bytes')
|
|
request={'operation':'render_full','config':inputs['helper-full-maintenance.json']['bytes'],'pin':inputs['full-maintenance-helper-proof.json']['bytes'],'job_public_key_hex':key['public_key_hex'],'new_helper_sha256':build['artifacts']['source0']['helper']['sha256']}
|
|
command=['docker','run','--rm','-i','--network','none','--read-only','--tmpfs','/tmp:rw,size=64m','-v',str(binary)+':/sdk:ro','--entrypoint','/sdk','sha256:9a76ad3744ebfdddae96ca10001ce8291c1b332fb54c8df5eea0e8e999ac6fc6']
|
|
rendered=subprocess.run(command,input=json.dumps(request).encode(),capture_output=True,check=True,timeout=30);transition=json.loads(rendered.stdout)
|
|
ident=str(uuid.uuid4());folder=ROOT/'devstate/linux-updater-compatible'/ident;folder.mkdir(mode=0o700,parents=True)
|
|
files={}
|
|
for name,item in [('agent.bin',build['artifacts']['source0']['agent']),('helper.bin',build['artifacts']['source0']['helper']),('updater.bin',build['stable_updater']),('sdk.bin',sdk['binary'])]:
|
|
raw=Path(item['path']).read_bytes();require(sha(raw)==item['sha256']and len(raw)==item['bytes'],'sealed exact code artifact');files[name]=raw
|
|
files['full-config.json']=bytes(transition['config']);files['full-pin.json']=bytes(transition['pin'])
|
|
unit=ROOT/'devstate/linux-updater-qualification/21d20391-6102-4996-8a7a-efbd3e78bd7d/source0/deploy/linux/rmm-agent-updater.service';files['updater.service']=unit.read_bytes()
|
|
proof=transition['proof'];require(proof['new_helper_sha256']==build['artifacts']['source0']['helper']['sha256']and proof['old_config_sha256']==inputs['helper-full-maintenance.json']['sha256']and proof['old_pin_sha256']==inputs['full-maintenance-helper-proof.json']['sha256'],'typed exact Full transition')
|
|
for name,raw in files.items():once(folder/name,raw)
|
|
binding=full['binding'];payload={'schema_version':1,'profile':'linux_compatible_bootstrap_package_v1','case_id':ident,'boot_id':BOOT,'tenant_id':binding['tenant_id'],'agent_id':binding['agent_id'],'asset_id':binding['asset_id'],'enrollment_generation':binding['enrollment_generation'],'assignment_version':binding['assignment_version'],'build_manifest_sha256':BASE_SHA,'sdk_manifest_sha256':sha(sdk_manifest.read_bytes()),'old_agent_sha256':snapshot['binaries']['/usr/local/libexec/rmm-agent-remote']['sha256'],'old_helper_sha256':snapshot['binaries']['/usr/local/libexec/rmm-privileged-helper']['sha256'],'old_config_sha256':proof['old_config_sha256'],'old_pin_sha256':proof['old_pin_sha256'],'full_transition':proof,'files':{n:{'sha256':sha(raw),'bytes':len(raw),'base64':base64.b64encode(raw).decode()}for n,raw in files.items()},'job_authority':False}
|
|
once(folder/'package.json',json.dumps(payload,sort_keys=True,separators=(',',':')).encode());once(folder/'readonly-before.json',json.dumps(snapshot,sort_keys=True,indent=2).encode());once(folder/'public-inputs.json',json.dumps(inputs,sort_keys=True,indent=2).encode())
|
|
summary={k:v for k,v in payload.items()if k!='files'};summary['files']={n:{k:v for k,v in e.items()if k!='base64'}for n,e in payload['files'].items()};once(folder/'manifest.json',json.dumps(summary,sort_keys=True,indent=2).encode())
|
|
print(json.dumps({'package':str(folder/'package.json'),'manifest':str(folder/'manifest.json'),'case_id':ident,'local_only_preparation':True,'target_staged':False,'services_changed':False,'full_policy_sha256':proof['new_policy_sha256']}))
|
|
|
|
def main():
|
|
parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('action',choices=('prepare','public-inputs','central-check','stage','install','units','start','qualify','registry','trust','updater-start','passive-check','readback'));parser.add_argument('--package',type=Path);parser.add_argument('--sdk-manifest',type=Path);parser.add_argument('--trust-package',type=Path);args=parser.parse_args()
|
|
if args.action=='prepare':
|
|
if args.sdk_manifest is None:parser.error('--sdk-manifest required for preparation')
|
|
prepare(args.sdk_manifest);return
|
|
if args.package is None:parser.error('--package required for fixed native phases')
|
|
p=json.loads(args.package.read_text());require=lambda ok,msg:None if ok else(_ for _ in()).throw(RuntimeError(msg))
|
|
require(p['schema_version']==1 and p['profile']=='linux_compatible_bootstrap_package_v1'and p['boot_id']==BOOT,'reviewed exact package')
|
|
if args.action=='public-inputs':value=native_rpc(public_inputs,{'operation':'linux_compatible_public_inputs_v1'})
|
|
elif args.action=='central-check':value=native_rpc(central_closed,{'agent_id':p['agent_id'],'tenant_id':p['tenant_id']},config='server.conf')
|
|
elif args.action=='stage':value=native_rpc(stage,p,timeout=120)
|
|
elif args.action=='passive-check':
|
|
if args.trust_package is None:parser.error('--trust-package required for exact passive comparison')
|
|
trust=json.loads(args.trust_package.read_text());files=trust['files'];value=native_rpc(passive_check,{'tenant_id':p['tenant_id'],'agent_id':p['agent_id'],'record_sha256':files['installed-record.json']['sha256'],'policy_sha256':files['policy.json']['sha256'],'keyring_sha256':files['keyring.json']['sha256'],'health_pin_sha256':files['health-key.json']['sha256'],'agent_sha256':p['files']['agent.bin']['sha256'],'helper_sha256':p['files']['helper.bin']['sha256'],'updater_sha256':p['files']['updater.bin']['sha256'],'helper_policy_sha256':p['full_transition']['new_policy_sha256']},config='server.conf')
|
|
else:
|
|
payload={'case_id':p['case_id'],'action':args.action}
|
|
if args.action=='install':payload['central_fence']=native_rpc(central_closed,{'agent_id':p['agent_id'],'tenant_id':p['tenant_id']},config='server.conf')
|
|
if args.action=='trust':
|
|
if args.trust_package is None:parser.error('--trust-package required for protected trust installation')
|
|
payload['trust']=json.loads(args.trust_package.read_text())
|
|
value=native_rpc(pair,payload,timeout=120)
|
|
print(json.dumps(value))
|
|
if __name__=='__main__':main()
|