Files
rust-discovery/deploy/cloud_checkpoint_repair.py
T
2026-11-13 17:43:38 +01:00

159 lines
10 KiB
Python

#!/usr/bin/env python3
"""One signed development control-chain repair, never a job or grant repair."""
import argparse
import base64
import hashlib
import json
import os
from pathlib import Path
import uuid
import cloud_apt_reconcile_upgrade as upgrade
cloud=upgrade.cloud
require=cloud.require
STATE=cloud.ROOT/'devstate/checkpoint-chain-repair'
def prepared_json(path):
"""The bounded full historical witness exceeds ordinary 1 MiB DTOs."""
import stat
fd=os.open(path,os.O_RDONLY|os.O_NOFOLLOW)
with os.fdopen(fd,'r') as stream:
info=os.fstat(stream.fileno())
require(stat.S_ISREG(info.st_mode) and info.st_uid==os.getuid() and
stat.S_IMODE(info.st_mode)==0o600 and info.st_nlink==1 and info.st_size<=45*1024*1024,
'private bounded repair witness')
return json.load(stream)
def prepare_vm(payload):
import re
import shutil
import sqlite3
os.umask(0o077)
ident=str(uuid.UUID(payload['id']));state=Path('/var/lib/rmm-agent-remote');helper=Path('/var/lib/rmm-helper')
require(hashlib.sha256(Path('/usr/local/libexec/rmm-agent-remote').read_bytes()).hexdigest()==payload['agent_sha256'],'reviewed permanent agent')
require(json.loads((state/'identity.json').read_text())['agent_id']==payload['agent_id'],'fixed permanent device')
base=Path('/var/lib/rmm-apt-transaction');result=json.loads((base/'active/sandbox-result.json').read_text())
require(result['apt_exit_code']==0 and not result['reboot_required'],'ended native child required; never stop package manager')
root=Path('/var/lib/rmm-bootstrap-history')/('checkpoint-chain-repair-'+ident);root.mkdir(mode=0o700)
def create(path,data,mode=0o600):
fd=os.open(path,os.O_WRONLY|os.O_CREAT|os.O_EXCL|os.O_NOFOLLOW,mode)
with os.fdopen(fd,'wb') as f:f.write(data);f.flush();os.fsync(f.fileno());os.fchmod(f.fileno(),mode)
tool=base64.b64decode(payload['tool'],validate=True)
require(hashlib.sha256(tool).hexdigest()==payload['tool_sha256'],'qualified repair tool')
create(root/'checkpoint-repair',tool,0o755)
subprocess.run(['/lib64/ld-linux-x86-64.so.2','--list',str(root/'checkpoint-repair')],capture_output=True,check=True,timeout=10)
binding=json.loads((state/'binding.json').read_text())
config=json.loads(Path('/etc/rmm-remote/helper-general.json').read_text())
pin=json.loads(Path('/etc/rmm-remote/helper-signing-key.json').read_text())
require(all(binding[k]==config['binding'][k] for k in ('tenant_id','asset_id','agent_id','enrollment_generation','assignment_version')) and
binding['public_key_hex']==pin['public_key_hex'],'independent root trust binding')
create(root/'binding.json',json.dumps(binding).encode())
units=('rmm-agent-remote.service','rmm-helper-cloud.service','rmm-apt-helper.service')
before={name:subprocess.run(['systemctl','show',name,'-p','ActiveState','--value'],capture_output=True,check=True).stdout.strip().decode() for name in units}
subprocess.run(['systemctl','stop',*units],capture_output=True,check=True,timeout=25)
prepared=False;report=dict(id=ident,vm_dir=str(root),tool_sha256=payload['tool_sha256'],prepared=False,package_effects=False)
try:
paths=(state/'journal.sqlite',state/'consumption.sqlite',helper/'consumption.sqlite')
hashes={str(p):hashlib.sha256(p.read_bytes()).hexdigest() for p in paths}
for index,p in enumerate(paths):
with sqlite3.connect(p.as_uri()+'?mode=ro',uri=True) as db:
require(db.execute('PRAGMA integrity_check').fetchone()[0]=='ok','preserved database integrity')
create(root/('database-before-'+str(index)+'.sqlite'),p.read_bytes())
process=subprocess.run([str(root/'checkpoint-repair'),'prepare',str(root/'binding.json'),str(root/'evidence.json')],
env=dict(PATH='/usr/sbin:/usr/bin:/sbin:/bin',RMM_CHECKPOINT_REPAIR_PROFILE='development'),capture_output=True,timeout=25)
create(root/'prepare.stderr',process.stderr)
require(all(hashlib.sha256(p.read_bytes()).hexdigest()==hashes[str(p)] for p in paths),'prepare must not change databases')
report.update(exit_code=process.returncode,error_codes=[x.decode() for x in re.findall(rb'\b(?:REPAIR_|CHECKPOINT_)[A-Z0-9_]+\b',process.stderr)],preserved_database_bytes=True)
if process.returncode==0:
raw=(root/'evidence.json').read_bytes();require(len(raw)<=32*1024*1024,'bounded evidence')
report.update(prepared=True,evidence_sha256=hashlib.sha256(raw).hexdigest(),evidence_b64=base64.b64encode(raw).decode())
prepared=True
finally:
create(root/'report.json',json.dumps({k:v for k,v in report.items() if k!='evidence_b64'}).encode())
if not prepared:
for unit in units:
if before[unit]=='active':subprocess.run(['systemctl','start',unit],capture_output=True,timeout=20)
return report
def issue_server(payload):
root=Path('/opt/rust-discovery')
raw=base64.b64decode(payload['evidence_b64'],validate=True)
require(hashlib.sha256(raw).hexdigest()==payload['evidence_sha256'],'original exact witness bytes')
cmd=['docker','compose','--env-file',str(root/'devstate/.env'),'-f',str(root/'deploy/server.compose.yaml'),
'exec','-T','api','/usr/local/bin/rmm-server','repair-unsent-sync-request']
result=subprocess.run(cmd,input=raw,capture_output=True,timeout=30)
require(result.returncode==0,'signed control receipt issuance failed')
value=json.loads(result.stdout);require(set(value)=={'payload','signature'},'only signed control receipt output')
return value
def apply_vm(payload):
import re
os.umask(0o077)
ident=str(uuid.UUID(payload['id']));root=Path('/var/lib/rmm-bootstrap-history')/('checkpoint-chain-repair-'+ident)
require(hashlib.sha256((root/'evidence.json').read_bytes()).hexdigest()==payload['evidence_sha256'] and
hashlib.sha256((root/'checkpoint-repair').read_bytes()).hexdigest()==payload['tool_sha256'],'original repair witnesses/tool')
signed=json.dumps(payload['receipt'],separators=(',',':')).encode();path=root/'receipt.json'
if path.exists():require(path.read_bytes()==signed,'identical existing receipt only')
else:
fd=os.open(path,os.O_WRONLY|os.O_CREAT|os.O_EXCL|os.O_NOFOLLOW,0o600)
with os.fdopen(fd,'wb') as f:f.write(signed);f.flush();os.fsync(f.fileno())
result=subprocess.run([str(root/'checkpoint-repair'),'apply',str(root/'binding.json'),str(root/'evidence.json'),str(path)],
env=dict(PATH='/usr/sbin:/usr/bin:/sbin:/bin',RMM_CHECKPOINT_REPAIR_PROFILE='development'),capture_output=True,timeout=25)
fd=os.open(root/'apply.stderr',os.O_WRONLY|os.O_CREAT|os.O_EXCL|os.O_NOFOLLOW,0o600)
with os.fdopen(fd,'wb') as f:f.write(result.stderr)
return dict(applied=result.returncode==0,exit_code=result.returncode,error_codes=[x.decode() for x in re.findall(rb'\b(?:REPAIR_|CHECKPOINT_)[A-Z0-9_]+\b',result.stderr)],
ready_lease_issued=False,jobs_created=False,grants_created=False)
def status_vm(payload):
import sqlite3
result={}
for name,path,table in (('agent','/var/lib/rmm-agent-remote/journal.sqlite','reconcile_meta'),
('helper','/var/lib/rmm-helper/consumption.sqlite','helper_sync_meta')):
with sqlite3.connect(Path(path).as_uri()+'?mode=ro',uri=True) as db:
tables={r[0] for r in db.execute("SELECT name FROM sqlite_master WHERE type='table'")}
result[name]=dict(faults=db.execute('SELECT count(*) FROM '+table+' WHERE fault IS NOT NULL').fetchone()[0],
receipts=db.execute('SELECT count(*) FROM checkpoint_repair_receipts').fetchone()[0] if 'checkpoint_repair_receipts' in tables else 0,
integrity_ok=db.execute('PRAGMA integrity_check').fetchone()[0]=='ok')
if name=='helper':
result[name].update(consumed=db.execute('SELECT count(*) FROM consumed').fetchone()[0],
unresolved=db.execute('SELECT count(*) FROM consumed WHERE result IS NULL').fetchone()[0])
result['services']={name:subprocess.run(['systemctl','show',name,'-p','ActiveState','--value'],capture_output=True,check=True).stdout.strip().decode()
for name in ('rmm-agent-remote.service','rmm-helper-cloud.service','rmm-apt-helper.service')}
return result
def main():
parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('action',choices=('prepare','issue','apply'));parser.add_argument('--id')
args=parser.parse_args();os.umask(0o077);STATE.mkdir(mode=0o700,exist_ok=True);m=cloud.contract
if args.action=='prepare':
require(upgrade.apt.prior.evidence('gate')==dict(jobs=13,outbox=13,permits=12,unresolved=1),'exact no-new-execution gate')
ident=str(uuid.uuid4());folder=STATE/ident;folder.mkdir(mode=0o700)
tool=(upgrade.STATE/'checkpoint-repair').read_bytes();installed=m.protected_json(cloud.ROOT/'devstate/remote-vm.json')
result=cloud.bootstrap.rpc('linux-vm.conf',prepare_vm,dict(id=ident,agent_id=installed['identity']['agent_id'],agent_sha256=installed['binary_sha256'],
tool_sha256=hashlib.sha256(tool).hexdigest(),tool=base64.b64encode(tool).decode()))
m.write_private(folder/'prepared.json',result)
print({k:result.get(k) for k in ('id','prepared','exit_code','error_codes','preserved_database_bytes')})
require(result['prepared'],'stored witness preparation incomplete; no fault changes')
else:
ident=str(uuid.UUID(args.id));folder=STATE/ident;prepared=prepared_json(folder/'prepared.json');require(prepared['prepared'],'qualified original witnesses')
if args.action=='issue':
result=cloud.bootstrap.rpc('server.conf',issue_server,prepared);m.write_private(folder/'receipt.json',result)
print(dict(signed_control_receipt=True,execution_permission=False))
else:
result=cloud.bootstrap.rpc('linux-vm.conf',apply_vm,dict(prepared,receipt=m.protected_json(folder/'receipt.json')))
m.write_private(folder/'applied.json',result);print(result)
if __name__=='__main__':
try:main()
except Exception as error:
message=str(error)
if message.startswith('remote bootstrap incomplete: '):print(message)
else:print('CLOUD_CHECKPOINT_REPAIR_INCOMPLETE:'+type(error).__name__)
raise SystemExit(2) from None