Files
LEAF/tests/test_repairs.py
2026-11-15 17:42:55 +01:00

212 lines
12 KiB
Python

"""Regression tests for ingestion, replay, persistence and credential handling."""
import copy
import importlib.util
import json
import os
from pathlib import Path
import socket
import sys
import tempfile
import threading
import time
import unittest
from unittest.mock import patch, Mock
sys.path.insert(0, str(Path(__file__).resolve().parents[1]/'controller'))
from leaf_controller.alertsock import AlertSocket, MAX_RECORD
from leaf_controller.config import Config, DEFAULTS, load_config, read_key_env
from leaf_controller.eve import EveTailer
from leaf_controller.main import Audit, Controller
from leaf_controller.vyos_client import VyosClient
from test_controller import Router
ROOT=Path(__file__).resolve().parents[1]
def module(name, path):
spec=importlib.util.spec_from_file_location(name, ROOT/path)
m=importlib.util.module_from_spec(spec);spec.loader.exec_module(m);return m
rotation=module('key_rotation', 'scripts/rotate-vyos-key.py')
retention=module('eve_rotation', 'scripts/rotate-eve.py')
injector=module('injector','tests/drill_synsensor.py')
class Repairs(unittest.TestCase):
def setUp(self):
self.tmp=tempfile.TemporaryDirectory();self.root=Path(self.tmp.name)
def tearDown(self): self.tmp.cleanup()
def controller(self):
raw=copy.deepcopy(DEFAULTS)
raw.update(state_db=str(self.root/'state'),audit_log=str(self.root/'audit'))
raw['alert_socket']['path']=str(self.root/'alerts.sock')
raw['policy'].update(mode='immediate',block_src=True)
with patch.object(Config,'vyos_key',return_value='fake'):
c=Controller(Config(raw))
c.client=Router();self.addCleanup(c.close);return c
def event(self):
return dict(event_type='alert',src_ip='203.0.113.12',dest_ip='192.0.2.202',
alert=dict(signature_id=1000001,metadata=dict(leaf_action=['block'])))
def test_dry_run_preserves_live_socket_and_audit(self):
c=self.controller();c._sock.bind()
before=os.stat(c._sock.path).st_ino
dry=Controller(c.cfg,dry_run=True)
try:
dry.handle_event(self.event())
self.assertIsNone(dry._sock)
finally: dry.close()
self.assertEqual(os.stat(c._sock.path).st_ino,before)
self.assertEqual((self.root/'audit').read_text(),'')
def test_distinct_state_cannot_steal_socket(self):
a=AlertSocket(str(self.root/'sock'));a.bind();self.addCleanup(a.close)
b=AlertSocket(a.path)
with self.assertRaises(OSError):b.bind()
self.assertTrue(Path(a.path).exists())
def test_unmanaged_active_listener_preserved(self):
path=str(self.root/'sock')
with socket.socket(socket.AF_UNIX) as s:
s.bind(path);s.listen()
with self.assertRaises(OSError):AlertSocket(path).bind()
self.assertTrue(Path(path).exists())
def test_non_socket_path_preserved(self):
p=self.root/'sock';p.write_text('preserve')
with self.assertRaises(OSError):AlertSocket(str(p)).bind()
self.assertEqual(p.read_text(),'preserve')
def test_shutdown_persists_accepted_queue(self):
c=self.controller();c._sock._enqueue(json.dumps(self.event()).encode())
c.close()
from leaf_controller.state import State
state=State(str(self.root/'state'))
try:self.assertIsNotNone(state.get('192.0.2.202'))
finally:state.close()
def test_oversized_and_recursive_frames_do_not_kill_reader(self):
a=AlertSocket(str(self.root/'sock'));a.bind();a.start();self.addCleanup(a.close)
with socket.socket(socket.AF_UNIX) as s:
s.connect(a.path)
s.sendall(b'x'*(MAX_RECORD+65536)+b'\n'+b'['*2000+b']'*2000+b'\n'+
json.dumps(self.event()).encode()+b'\n')
self.assertTrue(a.available.wait(3))
self.assertGreaterEqual(a.counts['parse_errors'],1)
self.assertEqual(a.counts['parse_errors']+a.counts['other'],2)
self.assertEqual(len(a.drain()),1)
self.assertTrue(a._thread.is_alive())
def test_partial_eof_counted(self):
a=AlertSocket(str(self.root/'sock'));a.bind();a.start();self.addCleanup(a.close)
with socket.socket(socket.AF_UNIX) as s:s.connect(a.path);s.sendall(b'{')
end=time.monotonic()+2
while a.counts['parse_errors']==0 and time.monotonic()<end:time.sleep(.01)
self.assertEqual(a.counts['parse_errors'],1)
def test_checkpoint_does_not_skip_unread_batch(self):
p=self.root/'eve';p.write_text('{"n":1}\n{"n":2}\n{"n":3}\n')
t=EveTailer(str(p),from_start=True);g=t.events()
self.assertEqual(next(g),{'n':1});ck=(*t._ino,t._pos);g.close()
self.assertEqual(ck[2],len('{"n":1}\n'))
t=EveTailer(str(p),checkpoint=ck);g=t.events()
self.assertEqual(next(g),{'n':2});g.close()
def test_replayed_file_hit_does_not_inflate_threshold(self):
c=self.controller();c.cfg.raw['policy'].update(mode='threshold',min_hits=2)
c.state._local.event_key='1:2:10'
c.handle_event(self.event());c.handle_event(self.event())
self.assertIsNone(c.state.get('192.0.2.202'))
c.state._local.event_key='1:2:20';c.handle_event(self.event())
self.assertIsNotNone(c.state.get('192.0.2.202'))
def test_failed_save_retried_after_membership_already_matches(self):
c=self.controller();c.cfg.raw['save_config']=True;c.handle_event(self.event())
c.client.save_config=Mock(side_effect=[RuntimeError('save failed'),None])
with self.assertRaises(RuntimeError):c.sync_router_state()
self.assertTrue(c.state.router_dirty())
c.sync_router_state()
self.assertEqual(c.client.save_config.call_count,2)
self.assertEqual(len(c.client.commits),1)
self.assertFalse(c.state.router_dirty())
def test_audit_keeps_latest_in_rapid_rotation(self):
p=self.root/'log';a=Audit(str(p),max_bytes=1,keep=3)
for i in range(20):a.write({'i':i})
a.close()
rows=[json.loads(f.read_text())['i'] for f in self.root.glob('log.*')]
self.assertEqual(sorted(rows),[17,18,19])
def test_tls_pins_do_not_mutate_global_or_other_clients(self):
from urllib3.poolmanager import pool_classes_by_scheme
before=dict(pool_classes_by_scheme)
a=VyosClient('https://localhost','x',cert_pin='a'*64)
b=VyosClient('https://localhost','x',cert_pin='b'*64)
self.assertEqual(pool_classes_by_scheme,before)
self.assertFalse(a.sess.trust_env)
self.assertEqual(a.sess.adapters['https://'].poolmanager.pool_classes_by_scheme['https'].ConnectionCls.leaf_pin,'a'*64)
self.assertEqual(b.sess.adapters['https://'].poolmanager.pool_classes_by_scheme['https'].ConnectionCls.leaf_pin,'b'*64)
def test_rotation_reopens_and_keeps_newest(self):
p=self.root/'eve';p.write_text('first\n');calls=[]
for i in range(9):
p.write_text(str(i))
retention.rotate(p,max_bytes=1,keep=3,reopen=lambda:(calls.append(1),p.write_text('')))
self.assertEqual(len(calls),9)
self.assertEqual(sorted(int(f.read_text()) for f in self.root.glob('eve.leaf-*')),[6,7,8])
def test_rotation_reopen_failure_restores_file(self):
p=self.root/'eve';p.write_text('original')
with self.assertRaises(RuntimeError):
retention.rotate(p,max_bytes=1,reopen=Mock(side_effect=RuntimeError()))
self.assertEqual(p.read_text(),'original')
def test_env_quotes_are_parsed_without_evaluation(self):
p=self.root/'env';p.write_text("LEAF_VYOS_KEY='abc123'\n")
self.assertEqual(read_key_env(p),'abc123')
def test_invalid_queue_and_ttl_rejected(self):
p=self.root/'config'
for value in ('alert_socket: {queue_size: 0}', 'policy: {ttl_seconds: -1}', 'policy: {min_hits: 1.5}'):
p.write_text(value)
with self.assertRaises(ValueError):load_config(p)
def test_key_rotation_preserves_other_app_ids(self):
old=Mock();new=Mock();old.retrieve.return_value={'data':{'id':{'leaf':{'key':'old'},'other':{'key':'unrelated'}}}}
with patch.object(rotation,'wait_auth'),patch.object(rotation,'atomic_env'),patch.object(rotation,'restart_service'):
rotation.rotate(old,new,'leaf','leaf-new','old','new','LEAF_VYOS_KEY=old\n','IDS-BLOCK')
self.assertEqual(new.configure.call_args.args[0]['path'],rotation.KEYS_PATH+['leaf'])
self.assertEqual(new.configure.call_count,1)
def test_key_rotation_restart_failure_rolls_back(self):
old=Mock();new=Mock();old.retrieve.return_value={'data':{'id':{'leaf':{'key':'old'}}}}
with patch.object(rotation,'wait_auth'),patch.object(rotation,'atomic_env') as write,patch.object(rotation,'restart_service',side_effect=[RuntimeError('failed'),None]):
with self.assertRaises(RuntimeError):rotation.rotate(old,new,'leaf','new-id','old','new','LEAF_VYOS_KEY=old\n','IDS-BLOCK')
self.assertEqual(write.call_args.args[0],'LEAF_VYOS_KEY=old\n')
self.assertEqual(old.configure.call_args.args[0]['path'],rotation.KEYS_PATH+['new-id'])
new.configure.assert_not_called()
def test_key_rotation_refuses_nonmatching_id(self):
old=Mock();old.retrieve.return_value={'data':{'id':{'other':{'key':'different'}}}}
with self.assertRaises(RuntimeError):rotation.rotate(old,Mock(),'other','new','old','new','text','group')
old.configure.assert_not_called()
def test_live_injector_uses_resolved_ethernet_addresses(self):
fake=Mock();fake.__enter__=Mock(return_value=fake);fake.__exit__=Mock(return_value=False)
with patch.object(sys,'argv',['injector','syn','--src','203.0.113.12','--dst','192.0.2.201','--count','1','--interval','0']),patch.object(injector,'route_via',return_value=('10.0.249.0','eth1')),patch.object(Path,'read_text',return_value='11:22:33:44:55:66'),patch.object(injector,'resolve_gateway_mac',return_value=bytes.fromhex('665544332211')),patch.object(injector.socket,'socket',return_value=fake):
injector.main()
self.assertEqual(fake.send.call_args.args[0][:12],bytes.fromhex('665544332211112233445566'))
def test_hourly_rotation_clock_survives_continuous_writes(self):
p=self.root/'eve';p.write_text('one')
self.assertFalse(retention.rotate(p,max_bytes=999999,now=100,reopen=lambda:None))
p.write_text('two')
self.assertTrue(retention.rotate(p,max_bytes=999999,now=3701,reopen=lambda:p.write_text('')))
def test_rotation_skips_engine_startup(self):
with patch.object(sys,'argv',['rotate-eve']),patch.object(retention.subprocess,'run',return_value=Mock(stdout='100000000')),patch.object(retention.time,'monotonic',return_value=101),patch.object(retention,'rotate') as r:
retention.main()
r.assert_not_called()
def test_diagnostics_redact_nested_credentials(self):
from leaf_controller.ops import redact
result=redact({'service':{'api':{'keys':{'id':{'leaf':{'key':'secret'}}}}},
'password':'secret', 'interfaces':{'eth1':{'address':['10.0.249.1/31']}}})
self.assertNotIn('secret',json.dumps(result))
self.assertEqual(result['interfaces']['eth1']['address'],['10.0.249.1/31'])
def test_file_identity_can_count_both_candidate_targets(self):
c=self.controller();c.cfg.raw['policy'].update(mode='threshold',min_hits=2)
c.state._local.event_key='one-file-record'
event=self.event();event['alert']['metadata']['leaf_action']=['block','block_src']
c.handle_event(event)
self.assertEqual(c.state.hit_count(1000001,'192.0.2.202',300),1)
self.assertEqual(c.state.hit_count(1000001,'203.0.113.12',300),1)
def test_malformed_stats_does_not_poison_following_alerts(self):
c=self.controller()
for stats in ({'capture':[1]}, {'uptime':'bad'}, {'uptime':float('inf')}):
c._route({'event_type':'stats','stats':stats})
c._route(self.event())
self.assertIsNotNone(c.state.get('192.0.2.202'))
def test_nonfinite_signature_does_not_stop_processing(self):
c=self.controller();bad=self.event();bad['alert']['signature_id']=float('inf')
c.handle_event(bad);c.handle_event(self.event())
self.assertIsNotNone(c.state.get('192.0.2.202'))