#!/usr/bin/env python3 """Real mTLS sync/signature/checkpoint/key/inventory denials, no approvals/effects.""" import datetime import hashlib import json import os from pathlib import Path import ssl import subprocess import tempfile import uuid from cryptography.exceptions import InvalidSignature from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey from local_integration import LocalHTTPS, CA, STATE, A, B, field, envelope, token, sql, check from backend_transport import fields, batch, csr, context, exchange from backend_contract import request def get(path, ctx, headers=None): c=LocalHTTPS("rmm-dev.internal",18443,context=ctx,timeout=10) c.request("GET",path,headers=headers or {}) r=c.getresponse(); result=(r.status,r.read());c.close();return result def verify(_folder, key, payload, signature): # Host CLI is OpenSSL 1.1.1, whose pkeyutl lacks -rawin. Verify with the # installed independent Python Ed25519 implementation, not a skipped check. try: Ed25519PublicKey.from_public_bytes(bytes.fromhex(key["public_key_hex"])).verify(signature,payload) return True except (InvalidSignature,ValueError): return False class Flow: def __init__(self, agent, ctx): self.agent,self.ctx,self.sequence,self.generation=agent,ctx,0,0 def send(self, tag, body): self.sequence+=1 return exchange("/agent/v1/messages",batch(envelope(self.agent,self.sequence,self.generation,tag,body)),self.ctx) def hello(self): self.generation=0 status,raw=self.send(10,field(1,"sync-fixture")+field(2,"rmm.sync.v1")+field(2,"run_script")) assert status==200,"sync-aware hello failed" self.generation=fields(fields(fields(raw)[2][0])[11][0])[1][0] def sync(self, body): status,raw=self.send(27,body) if status!=200:return status,None,None result=fields(fields(fields(raw)[2][0])[28][0]) return status,result[1][0],result[2][0] def sync_body(journal, checkpoint, previous="", request_id=None, previous_request="",helper=None,helper_previous="",attempts=()): request_id=request_id or str(uuid.uuid4()) body=field(1,request_id)+field(2,journal)+field(3,checkpoint) if previous:body+=field(4,previous) body+=field(5,1)+b"".join(field(6,attempt) for attempt in attempts)+field(8,1) if helper:body+=field(9,helper)+field(10,checkpoint) if helper_previous:body+=field(11,helper_previous) if previous_request:body+=field(12,previous_request) return request_id,body def snapshot(value): raw=json.dumps(value,separators=(",",":")).encode() return b"".join([field(1,str(uuid.uuid4())),field(2,"linux.base"),field(3,1),field(5,1),field(6,raw),field(7,hashlib.sha256(raw).digest()),field(8,"partial")]) def main(): with tempfile.TemporaryDirectory(prefix="backend-sync-",dir=STATE) as folder: folder=Path(folder) _,_,enrolled=request("/agent/v1/enroll","POST",{"token":token(A),"csr_pem":csr(folder,"device")}) agent,asset=enrolled["agent_id"],enrolled["asset_id"] ctx=context(folder,"device",enrolled["certificate_pem"]) flow=Flow(agent,ctx) try: status,raw=get("/api/v1/job-signing-key",ctx);key=json.loads(raw) check(status==200 and set(key)=={"key_id","algorithm","schema_version","public_key_hex"} and key["algorithm"]=="Ed25519" and key["schema_version"]==1 and hashlib.sha256(bytes.fromhex(key["public_key_hex"])).hexdigest()==key["key_id"],"registered device mTLS bootstrap gets exact stable signing-key profile") check(get("/api/v1/job-signing-key",ctx,{"Authorization":"Bearer invalid"})[0]==401,"explicit invalid bearer cannot fall back to mTLS key identity") flow.hello() check(sql(f"SELECT sync_required AND NOT sync_ready FROM agent_installations WHERE agent_id='{agent}';")=="t","negotiated sync gate closes on connection establishment") journal,helper=str(uuid.uuid4()),str(uuid.uuid4()) rid,body=sync_body(journal,1,helper=helper) status,payload,signature=flow.sync(body);assert status==200 decision=json.loads(payload) check(decision["ready"] and decision["helper_ready"] and decision["tenant_id"]==A and decision["asset_id"]==asset and decision["agent_id"]==agent and decision["connection_generation"]==flow.generation and decision["request_hash"]==hashlib.sha256(body).hexdigest(),"authoritative empty-journal sync opens only bound current generation") check(verify(folder,key,payload,signature),"independent Ed25519 verification of exact reconcile decision bytes") check(not verify(folder,key,payload+b" ",signature),"modified reconcile decision bytes fail independent verification") status,replayed,replayed_signature=flow.sync(body) check(status==200 and replayed==payload and replayed_signature==signature,"same sync ID/content returns one persisted signed checkpoint") _,changed=sync_body(journal,2,request_id=rid,helper=helper) check(flow.sync(changed)[0]==409,"same sync ID with changed checkpoint denied") prior_generation=flow.generation;flow.hello() check(flow.generation>prior_generation and sql(f"SELECT sync_ready FROM agent_installations WHERE agent_id='{agent}';")=="f","clean reconnect fences old readiness until a fresh decision") check(flow.sync(body)[0]==409,"old-generation signed checkpoint cannot be replayed as current readiness") _,body2=sync_body(journal,2,decision["decision_id"],helper=helper,helper_previous=decision["decision_id"]) status,payload2,sig2=flow.sync(body2);assert status==200 decision2=json.loads(payload2) check(decision2["ready"] and decision2["helper_ready"] and verify(folder,key,payload2,sig2),"consistent agent/helper journals regain readiness after clean reconnect") lost_id,lost=sync_body(journal,3,decision2["decision_id"],helper=helper,helper_previous=decision2["decision_id"]) status,lost_payload,_=flow.sync(lost);assert status==200 lost_decision=json.loads(lost_payload) flow.hello() _,recovery=sync_body(journal,3,previous_request=lost_id,helper=helper,helper_previous=decision2["decision_id"]) status,payload3,_=flow.sync(recovery);assert status==200 recovered=json.loads(payload3) check(recovered["ready"],"lost response recovery uses durable previous request without replacement grant") now=datetime.datetime.now(datetime.timezone.utc).isoformat() inventory={"os":"Linux fixture","hostname":"synthetic-sync","architecture":"x86_64","root_total_bytes":2,"root_available_bytes":1,"root_available_inodes":1,"collection_started_at":now,"collection_completed_at":now,"observations":[{"scope":"linux.smart","source_id":"linux.smart","observed_at":now,"quality":"unsupported","completeness":"unknown","truncated":False,"error_code":"NOT_SUPPORTED","data":None}]} check(flow.send(13,snapshot(inventory))[0]==200,"additive RFC3339 observation metadata accepted through durable mTLS ingest") operator=(STATE/"operator-a.token").read_text().strip() stored=request(f"/api/v1/tenants/{A}/devices/{asset}",token=operator)[2]["inventory"] check(stored["observations"]==inventory["observations"],"stored extended metadata retains unsupported/unknown distinctions exactly") inventory["observations"][0]["data"]="x"*32768 check(flow.send(13,snapshot(inventory))[0]==409,"oversized individual observation fails before durable ACK") inventory["observations"][0]["data"]=None;inventory["observations"][0]["received_at"]=now check(flow.send(13,snapshot(inventory))[0]==409,"device cannot assert server receipt metadata") artifact=str(uuid.uuid4());job=str(uuid.uuid4());attempt=str(uuid.uuid4()) sql(f"INSERT INTO artifacts(tenant_id,artifact_id,sha256,size_bytes,media_type) VALUES('{B}','{artifact}','{hashlib.sha256(b'foreign fixture').hexdigest()}',15,'application/octet-stream');") path=f"/agent/v1/artifacts/{artifact}?job_id={job}&attempt_id={attempt}" check(get(path,ctx)[0]==404,"device cannot retrieve an unapproved or foreign artifact reference") check(get(path,ctx,{"Authorization":"Bearer "+operator})[0]==401,"agent artifact route cannot switch to bearer authority") check(flow.send(23,field(1,b'{"execution_identity":"root"}')+field(2,b'x'*64))[0]==409,"agent-supplied unsigned execution permit is never server authority") archive=b"synthetic sealed archive bytes "+uuid.uuid4().hex.encode();archive_hash=hashlib.sha256(archive).hexdigest();own_artifact=str(uuid.uuid4()) archive_dir=STATE/"jobs"/"artifacts"/A;archive_dir.mkdir(mode=0o700,parents=True,exist_ok=True) with open(os.open(archive_dir/archive_hash,os.O_CREAT|os.O_EXCL|os.O_WRONLY,0o600),"wb") as f:f.write(archive) sql(f"INSERT INTO artifacts(tenant_id,artifact_id,sha256,size_bytes,media_type) VALUES('{A}','{own_artifact}','{archive_hash}',{len(archive)},'application/octet-stream');") when=datetime.datetime.now(datetime.timezone.utc) plan_input={"targets":{"asset_ids":[asset]},"action":{"action":"run_script","interpreter":"posix_sh","script_utf8":"true\n","arguments":[],"expected_stdout":""},"execution_identity":"agent_service","schedule":{"not_before":when.isoformat(),"start_before":(when+datetime.timedelta(hours=1)).isoformat()},"max_runtime_seconds":60,"max_output_bytes":1024,"rollout":{"max_parallel":1,"halt_after_failures":1},"reason":"artifact reference fixture; never execute","artifact_ids":[own_artifact]} status,_,plan=request(f"/api/v1/tenants/{A}/operation-plans","POST",plan_input,operator);assert status==200 check(plan["plan_payload"]["artifact_references"][0]["artifact"]["sha256"]==archive_hash and hashlib.sha256(bytes(plan["plan_payload_bytes"])).hexdigest()==plan["plan_hash"],"plan binds verified actual artifact bytes to fixed job/attempt") reserved=plan["jobs"][0] scoped_path=f"/agent/v1/artifacts/{own_artifact}?job_id={reserved['job_id']}&attempt_id={reserved['attempt_id']}" check(get(scoped_path,ctx)[0]==404,"reserved plan IDs do not authorize artifact access before approval/job creation") _,_,missing_device=request("/agent/v1/enroll","POST",{"token":token(A),"csr_pem":csr(folder,"missing")}) missing_agent=missing_device["agent_id"] try: missing=Flow(missing_agent,context(folder,"missing",missing_device["certificate_pem"]));missing.hello();missing_journal=str(uuid.uuid4()) fake=field(1,reserved["job_id"])+field(2,reserved["attempt_id"])+field(3,reserved["job_payload_hash"])+field(5,"unconsumed")+field(6,"accepted") _,report=sync_body(missing_journal,1,attempts=[fake]);status,fault,_=missing.sync(report);assert status==200;fault=json.loads(fault) check(not fault["ready"] and sql(f"SELECT sync_recovery_required FROM agent_installations WHERE agent_id='{missing_agent}';")=="t","missing/unapproved server job creates durable non-executable reconciliation fault") _,omit=sync_body(missing_journal,2,fault["decision_id"]);status,blocked,_=missing.sync(omit) check(status==200 and not json.loads(blocked)["ready"],"omitting an unresolved missing attempt cannot reset readiness") finally:sql(f"UPDATE agent_installations SET revoked_at=now() WHERE agent_id='{missing_agent}';") # Only own synchronization metadata is removed to simulate a restored # server checkpoint. No jobs, approvals, grants, or VM records touched. sql(f"DELETE FROM agent_sync_state WHERE agent_id='{agent}';") _,rollback=sync_body(journal,4,recovered["decision_id"],helper=helper,helper_previous=recovered["decision_id"]) status,denied,_=flow.sync(rollback);assert status==200 check(not json.loads(denied)["ready"] and sql(f"SELECT restore_blocked FROM agent_installations WHERE agent_id='{agent}';")=="t","missing authoritative server checkpoint persists fail-closed restore gate") _,blank=sync_body(str(uuid.uuid4()),1) check(not json.loads(flow.sync(blank)[1])["ready"],"fresh empty journal cannot bypass known server checkpoint history") flow.sequence=0;flow.hello() _,regressed=sync_body(journal,5) check(not json.loads(flow.sync(regressed)[1])["ready"] and sql(f"SELECT sequence_regressed FROM agent_installations WHERE agent_id='{agent}';")=="t","journal sequence rollback never yields blind readiness") check(sql(f"SELECT count(*) FROM execution_permits e JOIN jobs j USING(tenant_id,job_id,attempt_id) WHERE j.agent_id='{agent}';")=="0","sync never creates execution grants") sql(f"UPDATE agent_installations SET revoked_at=now() WHERE agent_id='{agent}';") check(get("/api/v1/job-signing-key",ctx)[0]==401,"revoked device cannot bootstrap the signing key") finally: sql(f"UPDATE agent_installations SET revoked_at=now() WHERE agent_id='{agent}';") print("Backend sync/key/inventory/restore tests passed locally; no approvals or VM/root effects executed.") if __name__=="__main__":main()