tegwick
7ceac4372d
Assistant: codex Assistant-Model: gpt-6.1-sol Assistant-Session: 01a126e1-76f8-7643-8cf3-e93336539ade
165 lines
10 KiB
Python
165 lines
10 KiB
Python
"""Synthetic ready FD/control transport tests; no SSH/native/credentials."""
|
|
import importlib.util
|
|
from pathlib import Path
|
|
import fcntl
|
|
import io
|
|
import json
|
|
import os
|
|
import signal
|
|
import sys
|
|
import tempfile
|
|
import time
|
|
import unittest
|
|
from unittest.mock import patch
|
|
|
|
spec=importlib.util.spec_from_file_location('routes',Path(__file__).with_name('test_openbao_node_route.py'))
|
|
r=importlib.util.module_from_spec(spec);spec.loader.exec_module(r);s=r.s;f=r.f
|
|
spec=importlib.util.spec_from_file_location('wrapper',Path(__file__).with_name('openbao-negative-node-wrapper.py'))
|
|
w=importlib.util.module_from_spec(spec);spec.loader.exec_module(w)
|
|
NONCE='a'*64
|
|
|
|
class ReadyTests(unittest.TestCase):
|
|
def setUp(self):
|
|
s.CLEANING=False;s.REQUEST_DEADLINE=None;s.BUSINESS_MONOTONIC_DEADLINE=None;s.CLEANUP_MONOTONIC_DEADLINE=None
|
|
def marker(self,envelope=None):
|
|
e=envelope or f.envelope()
|
|
return {'schema':s.READY_SCHEMA,'session_nonce':NONCE,'proposal_id':s.PROPOSAL,'target':s.TARGET,
|
|
'executor_sha256':s.digest(Path(s.__file__).read_bytes()),'envelope_sha256':'b'*64,
|
|
'bao_health_identity_sha256':e['bao_health_identity_sha256'],'valid_until_epoch':e['valid_until_epoch'],
|
|
'receive_budget_seconds':15}
|
|
|
|
def test_emit_exact_ready_marker_to_distinct_local_pipe_and_close_endpoint(self):
|
|
e=f.envelope();s.start_execution_window(e);read_fd,write_fd=os.pipe();receipt={}
|
|
s.emit_private_ready(write_fd,NONCE,'b'*64,'b'*64,e,receipt)
|
|
raw=os.read(read_fd,4097);self.assertEqual(os.read(read_fd,1),b'');os.close(read_fd)
|
|
obj=json.loads(raw)
|
|
self.assertEqual(set(obj),set(self.marker(e)))
|
|
self.assertEqual(obj['session_nonce'],NONCE)
|
|
self.assertEqual(obj['executor_sha256'],s.digest(Path(s.__file__).read_bytes()))
|
|
self.assertTrue(receipt['private_ready_emitted'])
|
|
self.assertNotIn('human_token',obj);self.assertNotIn('coding_agent_token',obj)
|
|
|
|
def test_stdout_alias_pipe_fd_above_two_refused_without_marker(self):
|
|
e=f.envelope();s.start_execution_window(e);read_fd,write_fd=os.pipe();saved=os.dup(1);alias=None
|
|
try:
|
|
os.dup2(write_fd,1);alias=os.dup(1)
|
|
with self.assertRaisesRegex(s.Refused,'private_ready_stdio_alias_refused'):
|
|
s.emit_private_ready(alias,NONCE,'b'*64,'b'*64,e,{})
|
|
finally:
|
|
os.dup2(saved,1);os.close(saved);os.close(write_fd)
|
|
if alias is not None:os.close(alias)
|
|
self.assertEqual(os.read(read_fd,4096),b'');os.close(read_fd)
|
|
|
|
def test_nonce_or_envelope_binding_failure_emits_no_ready(self):
|
|
e=f.envelope();s.start_execution_window(e)
|
|
for nonce,pin in [('wrong','b'*64),(NONCE,'c'*64)]:
|
|
read_fd,write_fd=os.pipe()
|
|
try:
|
|
with self.assertRaises(s.Refused):s.emit_private_ready(write_fd,nonce,pin,'b'*64,e,{})
|
|
finally:
|
|
try:os.close(write_fd)
|
|
except OSError:pass
|
|
self.assertEqual(os.read(read_fd,4096),b'');os.close(read_fd)
|
|
|
|
def test_actual_full_ack_pipe_write_times_out_inside_original_window(self):
|
|
e=f.envelope();s.start_execution_window(e)
|
|
s.BUSINESS_MONOTONIC_DEADLINE=time.monotonic()+0.015
|
|
read_fd,write_fd=os.pipe();fcntl.fcntl(write_fd,fcntl.F_SETPIPE_SZ,4096)
|
|
flags=fcntl.fcntl(write_fd,fcntl.F_GETFL);fcntl.fcntl(write_fd,fcntl.F_SETFL,flags|os.O_NONBLOCK)
|
|
try:
|
|
while True:os.write(write_fd,b'x'*4096)
|
|
except BlockingIOError:pass
|
|
fcntl.fcntl(write_fd,fcntl.F_SETFL,flags)
|
|
started=time.monotonic();handler=signal.getsignal(signal.SIGALRM)
|
|
with self.assertRaisesRegex(s.Refused,'request_total_timeout'):
|
|
s.emit_private_ready(write_fd,NONCE,'b'*64,'b'*64,e,{})
|
|
self.assertLess(time.monotonic()-started,0.15);os.close(read_fd)
|
|
self.assertEqual(signal.getsignal(signal.SIGALRM),handler)
|
|
self.assertEqual(signal.getitimer(signal.ITIMER_REAL),(0.0,0.0))
|
|
|
|
def test_actual_main_health_ready_then_private_read_exact_order(self):
|
|
previous=signal.getsignal(signal.SIGTERM);read_fd,write_fd=os.pipe();events=[];received={}
|
|
try:
|
|
with tempfile.TemporaryDirectory() as folder:
|
|
e=f.envelope();path=Path(folder)/'approved.json';path.write_text(json.dumps(e));path.chmod(0o600)
|
|
pin=s.digest(path.read_bytes());receipt=Path(folder)/'receipt.json'
|
|
argv=['session','execute','--envelope',str(path),'--receipt',str(receipt),'--ready-fd',str(write_fd),
|
|
'--session-nonce',NONCE,'--ready-envelope-sha256',pin]
|
|
class Input:
|
|
first=True
|
|
def read(self,size):
|
|
if not self.first:return b''
|
|
self.first=False
|
|
received.update(json.loads(os.read(read_fd,4096)))
|
|
self_test.assertEqual(received['envelope_sha256'],pin)
|
|
events.append('private-read')
|
|
return b'{"human_token":"synthetic","coding_agent_token":"synthetic"}'
|
|
self_test=self;stream=type('Stream',(),{'buffer':Input()})()
|
|
def health():events.append('health');return e['bao_health_identity_sha256']
|
|
def execute(*args,**kwargs):events.append('execute');self.assertTrue(kwargs['window_started'])
|
|
with patch.object(sys,'argv',argv),patch.object(sys,'stdin',stream), \
|
|
patch.object(s,'SessionTransport') as factory,patch.object(s,'execute',side_effect=execute),patch.object(s,'k') as k:
|
|
factory.return_value.health_identity.side_effect=health
|
|
self.assertEqual(s.main(),0);k.assert_not_called()
|
|
self.assertEqual(events,['health','private-read','execute'])
|
|
self.assertEqual(received['session_nonce'],NONCE)
|
|
finally:
|
|
signal.signal(signal.SIGTERM,previous);os.close(read_fd)
|
|
try:os.close(write_fd)
|
|
except OSError:pass
|
|
|
|
def test_actual_main_missing_ack_fd_never_reads_private_input(self):
|
|
previous=signal.getsignal(signal.SIGTERM)
|
|
try:
|
|
with tempfile.TemporaryDirectory() as folder:
|
|
e=f.envelope();path=Path(folder)/'approved.json';path.write_text(json.dumps(e));path.chmod(0o600)
|
|
receipt=Path(folder)/'receipt.json';argv=['session','execute','--envelope',str(path),'--receipt',str(receipt)]
|
|
with patch.object(sys,'argv',argv),patch.object(sys,'stdin') as stdin,patch.object(s,'SessionTransport') as factory,patch.object(s,'k') as k:
|
|
factory.return_value.health_identity.return_value=e['bao_health_identity_sha256']
|
|
self.assertEqual(s.main(),1);stdin.buffer.read.assert_not_called();k.assert_not_called()
|
|
self.assertEqual(json.loads(receipt.read_text())['reason'],'private_ready_pipe_required')
|
|
finally:signal.signal(signal.SIGTERM,previous)
|
|
|
|
def test_wrapper_marker_pin_nonce_fields_and_window_failures_refuse(self):
|
|
e=f.envelope();marker=self.marker(e)
|
|
for key,value in [('session_nonce','c'*64),('executor_sha256','c'*64),('envelope_sha256','c'*64),
|
|
('target','other'),('proposal_id','other'),('bao_health_identity_sha256','c'*64),
|
|
('valid_until_epoch',True),('receive_budget_seconds',True),('receive_budget_seconds',float('inf'))]:
|
|
bad=dict(marker,**{key:value})
|
|
with self.subTest(key=key),self.assertRaises(w.Refused):
|
|
w.validate_marker(json.dumps(bad).encode()+b'\n',nonce=NONCE,executor_pin=marker['executor_sha256'],envelope_pin='b'*64,envelope=e)
|
|
with self.assertRaises(w.Refused):
|
|
w.validate_marker(json.dumps(dict(marker,extra=True)).encode()+b'\n',nonce=NONCE,executor_pin=marker['executor_sha256'],envelope_pin='b'*64,envelope=e)
|
|
|
|
def test_wrapper_ready_pipe_no_eof_is_bounded(self):
|
|
read_fd,write_fd=os.pipe();os.write(write_fd,b'{"incomplete":true}')
|
|
started=time.monotonic()
|
|
try:
|
|
with self.assertRaisesRegex(w.Refused,'wrapper_timeout'):
|
|
with w.deadline(0.015):w.read_ready(read_fd)
|
|
finally:os.close(write_fd);os.close(read_fd)
|
|
self.assertLess(time.monotonic()-started,0.15)
|
|
|
|
def test_wrapper_pinned_node_child_launch_is_local_pipe_not_ssh_fd_forward(self):
|
|
with tempfile.TemporaryDirectory() as folder:
|
|
child=Path(folder)/'child.py';child.write_text('# synthetic child, never executed\n')
|
|
envelope=f.envelope();envelope['source_hashes']={str(child):w.hash_bytes(child.read_bytes()),str(Path(w.__file__).resolve()):w.hash_bytes(Path(w.__file__).read_bytes())}
|
|
env=Path(folder)/'approved.json';env.write_text(json.dumps(envelope));env.chmod(0o600)
|
|
args=type('Args',(),{'child':str(child),'child_sha256':w.hash_bytes(child.read_bytes()),'envelope':str(env),'envelope_sha256':w.hash_bytes(env.read_bytes()),'receipt':str(Path(folder)/'receipt.json'),'session_nonce':NONCE})()
|
|
class Process:
|
|
stdout=io.BytesIO();stderr=io.BytesIO()
|
|
def wait(self,timeout):return 0
|
|
def poll(self):return 0
|
|
def launch(command,**kwargs):
|
|
self.assertEqual(command[0],sys.executable)
|
|
self.assertEqual(command[1],str(child));self.assertNotIn('ssh',command)
|
|
self.assertEqual(kwargs['stdin'],sys.stdin.buffer)
|
|
fd=int(command[command.index('--ready-fd')+1]);self.assertEqual(kwargs['pass_fds'],(fd,))
|
|
marker=self.marker(envelope);marker.update(executor_sha256=args.child_sha256,envelope_sha256=args.envelope_sha256)
|
|
os.write(fd,json.dumps(marker).encode()+b'\n')
|
|
return Process()
|
|
with patch.object(w.subprocess,'Popen',side_effect=launch),patch.object(w,'forward_ready') as forward:
|
|
self.assertEqual(w.run(args),0);self.assertEqual(forward.call_count,1)
|
|
self.assertNotIn('human_token',json.loads(forward.call_args.args[0]))
|
|
|
|
if __name__=='__main__':unittest.main(verbosity=2)
|