212 lines
12 KiB
Python
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'))
|