This commit is contained in:
2026-11-15 17:41:40 +01:00
parent e31f6f0ca1
commit 7864d2ed18
13 changed files with 1530 additions and 0 deletions

View File

@@ -0,0 +1,176 @@
"""sqlite-backed state: block list w/ TTL, hit windowing, applied tracking."""
from __future__ import annotations
import sqlite3
import time
import threading
from dataclasses import dataclass
SCHEMA = """
CREATE TABLE IF NOT EXISTS controller_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);
CREATE TABLE IF NOT EXISTS blocks (
ip TEXT PRIMARY KEY, -- ip/cidr as pushed to VyOS (plain ip = /32 semantics)
kind TEXT NOT NULL, -- dest|src
sigs TEXT NOT NULL DEFAULT '',-- csv of triggering sids
first_seen REAL NOT NULL,
last_hit REAL NOT NULL,
expires REAL NOT NULL,
applied INTEGER NOT NULL DEFAULT 0
);
CREATE TABLE IF NOT EXISTS hits (
sid INTEGER NOT NULL,
ip TEXT NOT NULL,
ts REAL NOT NULL
);
CREATE INDEX IF NOT EXISTS hits_idx ON hits (sid, ip, ts);
CREATE TABLE IF NOT EXISTS eve_ckpt (
id INTEGER PRIMARY KEY CHECK (id = 1),
dev INTEGER NOT NULL, -- st_dev/st_ino of the EVE file last read
ino INTEGER NOT NULL,
pos INTEGER NOT NULL, -- byte offset of the next unread record
updated_at REAL NOT NULL
);
"""
@dataclass
class BlockRow:
ip: str
kind: str
sigs: str
first_seen: float
last_hit: float
expires: float
applied: int
class State:
def __init__(self, path: str):
self.path = path
self._local = threading.local()
self.con.executescript(SCHEMA)
columns = {r[1] for r in self.con.execute("PRAGMA table_info(hits)")}
if "event_key" not in columns:
self.con.execute("ALTER TABLE hits ADD COLUMN event_key TEXT")
self.con.execute("CREATE UNIQUE INDEX IF NOT EXISTS hits_event ON hits(event_key)")
self.con.commit()
@property
def con(self):
# Alert processing and router I/O have independent connections.
if not hasattr(self._local, "con"):
con = sqlite3.connect(self.path, timeout=10)
con.execute("PRAGMA journal_mode=WAL")
con.execute("PRAGMA busy_timeout=10000")
self._local.con = con
return self._local.con
def close(self):
if hasattr(self._local, "con"):
self._local.con.close()
del self._local.con
# ---- hit windowing (threshold mode) ----
def record_hit(self, sid: int, ip: str, ts: float | None = None) -> None:
event_key = getattr(self._local, "event_key", None)
if event_key is not None:
event_key = f'{event_key}:{sid}:{ip}'
self.con.execute("INSERT OR IGNORE INTO hits (sid, ip, ts, event_key) VALUES (?,?,?,?)",
(sid, ip, ts or time.time(), event_key))
self.con.commit()
def hit_count(self, sid: int, ip: str, window: float, now: float | None = None) -> int:
now = now or time.time()
(n,) = self.con.execute(
"SELECT count(*) FROM hits WHERE sid=? AND ip=? AND ts>=?",
(sid, ip, now - window)).fetchone()
return n
def prune_hits(self, max_age: float, now: float | None = None) -> None:
now = now or time.time()
self.con.execute("DELETE FROM hits WHERE ts < ?", (now - max_age,))
self.con.commit()
# ---- blocks ----
def _row(self, r: sqlite3.Row | tuple) -> BlockRow:
return BlockRow(*r)
def get(self, ip: str) -> BlockRow | None:
r = self.con.execute("SELECT * FROM blocks WHERE ip=?", (ip,)).fetchone()
return self._row(r) if r else None
def upsert_hit(self, ip: str, kind: str, sid: int, ttl: float,
now: float | None = None) -> BlockRow:
"""Create block entry or refresh expiry/last_hit of existing one."""
now = now or time.time()
# Serialize the read/modify/write with expiry cleanup in the worker.
with self.con:
self.con.execute("BEGIN IMMEDIATE")
row = self.get(ip)
if row:
sigs = row.sigs
if str(sid) not in sigs.split(","):
sigs = f"{sigs},{sid}" if sigs else str(sid)
self.con.execute(
"UPDATE blocks SET expires=?, last_hit=?, sigs=? WHERE ip=?",
(now + ttl, now, sigs, ip))
else:
self.con.execute("INSERT INTO blocks VALUES (?,?,?,?,?,?,0)",
(ip, kind, str(sid), now, now, now + ttl))
result = self.get(ip)
return result
def set_applied(self, ip: str, applied: int = 1) -> None:
self.con.execute("UPDATE blocks SET applied=? WHERE ip=?", (applied, ip))
self.con.commit()
def remove(self, ip: str, expired_before: float | None = None) -> bool:
# A new alert may refresh a block while the router commit is in flight.
with self.con:
if expired_before is None:
cur = self.con.execute("DELETE FROM blocks WHERE ip=?", (ip,))
else:
cur = self.con.execute("DELETE FROM blocks WHERE ip=? AND expires<=?",
(ip, expired_before))
if cur.rowcount:
self.con.execute("DELETE FROM hits WHERE ip=?", (ip,))
return bool(cur.rowcount)
def all_blocks(self) -> list[BlockRow]:
return [self._row(r) for r in self.con.execute("SELECT * FROM blocks")]
def expired(self, now: float | None = None) -> list[BlockRow]:
now = now or time.time()
return [self._row(r) for r in
self.con.execute("SELECT * FROM blocks WHERE expires<=?", (now,))]
def unapplied(self) -> list[BlockRow]:
return [self._row(r) for r in
self.con.execute("SELECT * FROM blocks WHERE applied=0")]
def count_active(self, now: float | None = None) -> int:
now = now or time.time()
(n,) = self.con.execute("SELECT count(*) FROM blocks WHERE expires>?", (now,)).fetchone()
return n
# ---- EVE read checkpoint (survives controller restarts) ----
def get_checkpoint(self) -> tuple | None:
r = self.con.execute("SELECT dev, ino, pos FROM eve_ckpt WHERE id=1").fetchone()
return tuple(r) if r else None
def save_checkpoint(self, dev: int, ino: int, pos: int, now: float | None = None) -> None:
with self.con:
self.con.execute(
"INSERT INTO eve_ckpt VALUES (1,?,?,?,?) "
"ON CONFLICT(id) DO UPDATE SET dev=excluded.dev, ino=excluded.ino, "
"pos=excluded.pos, updated_at=excluded.updated_at",
(dev, ino, pos, now or time.time()))
def router_dirty(self):
r = self.con.execute("SELECT value FROM controller_meta WHERE key='router_dirty'").fetchone()
return bool(r and r[0] == '1')
def set_router_dirty(self, dirty):
with self.con:
self.con.execute("INSERT OR REPLACE INTO controller_meta VALUES ('router_dirty', ?)",
('1' if dirty else '0',))