Skip to content

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.

persistence: remembered device identities — learned names survive restarts

MoneyLisa6307e84cfc61
diff --git a/backend/api/main.py b/backend/api/main.py
index 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] = dev
edges[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"] = name
touched_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"] = pending
node["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"]] = node
edge_id = f"lan-edge-{device.ip}"
diff --git a/backend/storage/db.py b/backend/storage/db.py
index 490a1a3..9ea4aff 100644
--- a/backend/storage/db.py
+++ b/backend/storage/db.py
@@ -32,6 +32,7 @@ import sqlite3
import threading
from collections import defaultdict
from datetime import datetime, timedelta, timezone
+from typing import Optional
from 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: