Real-time network monitor + outbound firewall — see & block every connection. Privacy-first, local-first, Rust fleet agent, SIEM exports, 8 languages. / Moniteur réseau temps réel + pare-feu sortant, agent de flotte Rust, exports SIEM. 100 % local.
Python cybersecurityd3jsebpfedrelectronfastapifirewallfleet-managementlinuxlittle-snitch-alternativemacosnetwork-monitornetwork-securitypacket-captureprivacyreactrustself-hostedsiemwindows
persistence: remembered device identities — learned names survive restarts
MoneyLisa6307e84cfc61
diff --git a/backend/api/main.py b/backend/api/main.pyindex 68ea993..1282175 100644--- a/backend/api/main.py+++ b/backend/api/main.py@@ -251,6 +251,21 @@ def _ensure_lan_device(ip: str) -> dict:"online": True, "bytes": 0, "packets": 0,"color": "#f97316" if is_gw else "#64748b", "alerted": False,}+ # EN: A stub seen in traffic may already be a KNOWN device — recall+ # its persisted identity before showing a bare IP.+ # FR: Un stub vu dans le trafic peut être un appareil déjà CONNU —+ # rappeler son identité persistée avant d'afficher une IP nue.+ stored = db.device_identity(ip)+ if stored.get("hostname"):+ dev["hostname"] = stored["hostname"]+ dev["label"] = stored["hostname"]+ if stored.get("mac"):+ dev["mac"] = stored["mac"]+ dev["private_mac"] = stored.get("private_mac", False)+ if stored.get("vendor"):+ dev["vendor"] = stored["vendor"]+ if stored.get("device_type") and dev["device_type"] == "unknown":+ dev["device_type"] = stored["device_type"]lan_devices[key] = devedges[f"lan-edge-{ip}"] = {"id": f"lan-edge-{ip}", "source": "local", "target": key,@@ -340,6 +355,11 @@ def _learn_lan_hostname(ip: str, name: str,if dev.get("label") == dev.get("ip"):dev["label"] = nametouched_devices[dev["id"]] = dev+ # EN: A learned name is durable knowledge — persist it so a restart+ # doesn't drop the device back to a bare IP.+ # FR: Un nom appris est un savoir durable — le persister pour qu'un+ # redémarrage ne fasse pas retomber l'appareil sur une IP nue.+ db.upsert_device(ip=ip, mac=dev.get("mac"), hostname=name)def _devname(dns_name: str) -> Optional[str]:@@ -737,8 +757,31 @@ async def _handle_device(device: Device, is_new: bool) -> None:if pending and not node["hostname"]:node["hostname"] = pendingnode["label"] = pending- else:- node["alerted"] = False++ # EN: Recall the persisted identity — a device named in a previous+ # session keeps its name across restarts. MAC-verified (see db.py).+ # FR: Rappeler l'identité persistée — un appareil nommé lors d'une+ # session précédente garde son nom entre redémarrages. Vérifiée par+ # MAC (voir db.py).+ if not node["hostname"]:+ stored = db.device_identity(device.ip, device.mac)+ if stored.get("hostname"):+ node["hostname"] = stored["hostname"]+ node["label"] = stored["hostname"]+ if stored.get("vendor") and not node.get("vendor"):+ node["vendor"] = stored["vendor"]+ if stored.get("device_type") and node.get("device_type") in (None, "unknown"):+ node["device_type"] = stored["device_type"]++ # EN: Persist the freshest identity — next boot starts from knowledge,+ # not from zero.+ # FR: Persister l'identité la plus fraîche — le prochain démarrage part+ # d'un savoir, pas de zéro.+ db.upsert_device(ip=device.ip, mac=device.mac, vendor=device.vendor,+ device_type=device.device_type,+ hostname=node.get("hostname"),+ private_mac=device.private_mac)+lan_devices[node["id"]] = nodeedge_id = f"lan-edge-{device.ip}"diff --git a/backend/storage/db.py b/backend/storage/db.pyindex 490a1a3..9ea4aff 100644--- a/backend/storage/db.py+++ b/backend/storage/db.py@@ -32,6 +32,7 @@ import sqlite3import threadingfrom collections import defaultdictfrom datetime import datetime, timedelta, timezone+from typing import Optionalfrom paths import data_dir@@ -131,6 +132,27 @@ def _init_schema(conn: sqlite3.Connection) -> None:PRIMARY KEY (minute, dim, key));CREATE INDEX IF NOT EXISTS idx_history_lookup ON history(dim, key, minute);++ -- EN: Remembered LAN devices. Identities learned passively (mDNS,+ -- DHCP, NBNS, LLMNR, OUI) persist across restarts — a device once+ -- named never falls back to a bare IP again. NULL-safe upserts+ -- keep the best-known value for every field.+ -- FR: Appareils LAN mémorisés. Les identités apprises passivement+ -- (mDNS, DHCP, NBNS, LLMNR, OUI) survivent aux redémarrages —+ -- un appareil nommé une fois ne retombe jamais sur une IP nue.+ -- Les upserts NULL-safe gardent la meilleure valeur de chaque+ -- champ.+ CREATE TABLE IF NOT EXISTS devices (+ ip TEXT PRIMARY KEY,+ mac TEXT,+ vendor TEXT,+ device_type TEXT,+ hostname TEXT,+ private_mac INTEGER DEFAULT 0,+ first_seen TEXT,+ last_seen TEXT+ );+ CREATE INDEX IF NOT EXISTS idx_devices_mac ON devices(mac);""")conn.commit()@@ -173,6 +195,96 @@ def all_settings() -> dict:return out+# ── Remembered devices / Appareils mémorisés ─────────────────────────────────++def upsert_device(ip: str, mac: Optional[str] = None,+ vendor: Optional[str] = None,+ device_type: Optional[str] = None,+ hostname: Optional[str] = None,+ private_mac: Optional[bool] = None) -> None:+ """+ EN: Persist the best-known identity of a LAN device. NULL/empty fields+ never overwrite stored knowledge — a scan can only ENRICH a row.+ Called on ARP discovery and each passive name learning.+ FR: Persister la meilleure identité connue d'un appareil LAN. Les champs+ NULL/vides n'écrasent jamais un savoir stocké — un scan ne peut+ qu'ENRICHIR une ligne. Appelé à la découverte ARP et à chaque+ apprentissage passif de nom.+ """+ now = _utcnow_iso()+ try:+ with _conn_lock:+ conn = get_conn()+ conn.execute("""+ INSERT INTO devices (ip, mac, vendor, device_type, hostname,+ private_mac, first_seen, last_seen)+ VALUES (?, ?, ?, ?, ?, ?, ?, ?)+ ON CONFLICT(ip) DO UPDATE SET+ mac = COALESCE(excluded.mac, devices.mac),+ vendor = COALESCE(NULLIF(excluded.vendor, ''),+ devices.vendor),+ device_type = COALESCE(NULLIF(excluded.device_type, ''),+ devices.device_type),+ hostname = COALESCE(NULLIF(excluded.hostname, ''),+ devices.hostname),+ private_mac = COALESCE(excluded.private_mac,+ devices.private_mac),+ last_seen = excluded.last_seen+ """, (ip, mac, vendor, device_type, hostname,+ None if private_mac is None else int(private_mac),+ now, now))+ conn.commit()+ except sqlite3.Error as exc:+ logger.error("upsert_device(%s) failed: %s", ip, exc)+++def device_identity(ip: str, mac: Optional[str] = None) -> dict:+ """+ EN: Recall a stored identity for a device. MAC match wins (DHCP can+ reassign IPs to OTHER devices — an IP-only name could misname a+ newcomer); the IP row is only trusted when its MAC agrees or is+ unknown.+ FR: Rappeler l'identité stockée d'un appareil. La correspondance MAC+ gagne (le DHCP peut réassigner une IP à un AUTRE appareil — un nom+ par IP seule pourrait mal nommer un nouvel arrivant) ; la ligne IP+ n'est crédible que si sa MAC concorde ou est inconnue.+ """+ def _merge(best: dict, row: tuple) -> dict:+ r_mac, vendor, dtype, hostname, priv = row+ if r_mac and not best.get("mac"):+ best["mac"] = r_mac+ for key, val in (("vendor", vendor), ("device_type", dtype),+ ("hostname", hostname)):+ if val and key not in best:+ best[key] = val+ if priv is not None and "private_mac" not in best:+ best["private_mac"] = bool(priv)+ return best++ with _conn_lock:+ conn = get_conn()+ best: dict = {}+ if mac:+ row = conn.execute(+ "SELECT mac, vendor, device_type, hostname, private_mac "+ "FROM devices WHERE mac = ?", (mac,)).fetchone()+ if row:+ _merge(best, row)+ row = conn.execute(+ "SELECT mac, vendor, device_type, hostname, private_mac "+ "FROM devices WHERE ip = ?", (ip,)).fetchone()+ # EN: The IP-keyed row is trusted only when its stored MAC agrees+ # with the device in front of us (or is unknown) — DHCP reassigns+ # IPs, a stale IP→name binding would misname the newcomer.+ # FR: La ligne indexée par IP n'est fiable que si sa MAC stockée+ # concorde avec l'appareil en face de nous (ou est inconnue) —+ # le DHCP réassigne les IP, une liaison IP→nom périmée+ # nommerait mal le nouvel arrivant.+ if row and (not mac or not row[0] or row[0] == mac):+ _merge(best, row)+ return best++# ── Write helpers / Aides d'écriture ─────────────────────────────────────────def accumulate(minute: str, category: str, size: int) -> None: