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
"""
Snitch — microphone / camera usage monitor.
EN: Polls the OS to find which processes currently hold the microphone or
the camera. Powers the MEDIA_EXFIL anomaly rule: an unknown process using
the mic AND sending traffic out is a red flag.
- Windows: reads the ConsentStore registry keys. `LastUsedTimeStop == 0`
means the device is in use right now. Both packaged (Store/UWP) and
unpackaged (desktop) apps are covered — the earlier version only read
"NonPackaged" and missed every Store app.
- Linux: scans each process's open files for /dev/snd* and /dev/video*.
FR: Interroge l'OS pour savoir quels processus utilisent actuellement le
microphone ou la caméra. Alimente la règle MEDIA_EXFIL : un processus
inconnu qui utilise le micro ET émet du trafic est un signal d'alerte.
- Windows : lit les clés de registre ConsentStore. `LastUsedTimeStop == 0`
signifie que l'appareil est utilisé en ce moment. Les apps packagées
(Store/UWP) et non packagées (bureau) sont toutes deux couvertes — la
version précédente ne lisait que « NonPackaged » et ratait toutes les
apps du Store.
- Linux : scanne les fichiers ouverts de chaque processus à la recherche
de /dev/snd* et /dev/video*.
"""
import logging
import sys
import time
from dataclasses import dataclass, field
from typing import Callable
import psutil
logger = logging.getLogger("snitch.capture.media")
@dataclass
class MediaState:
"""EN: Snapshot of which process names are using mic/camera.
`supported=False` means the platform has no detection backend
(macOS) — the UI hides the badge entirely rather than lying.
FR: Instantané des noms de processus utilisant micro/caméra.
`supported=False` signifie que la plateforme n'a pas de backend de
détection (macOS) — l'UI masque complètement le badge plutôt que de
mentir."""
mic: list[str] = field(default_factory=list)
camera: list[str] = field(default_factory=list)
supported: bool = True
def _detect_windows() -> MediaState:
"""
EN: Read Windows' per-app consent store. Sub-keys of `microphone`/`webcam`
are either "NonPackaged" (a folder of desktop exe paths) or a packaged
app id. `LastUsedTimeStop == 0` means the device is open right now.
FR: Lire le magasin de consentement Windows par app. Les sous-clés de
`microphone`/`webcam` sont soit « NonPackaged » (un dossier de chemins
d'exe bureau), soit un identifiant d'app packagée.
`LastUsedTimeStop == 0` signifie que l'appareil est ouvert en ce moment.
"""
import winreg
state = MediaState()
def _key_in_use(key) -> bool:
"""EN: True if this app's LastUsedTimeStop == 0 (device in use now).
FR: True si LastUsedTimeStop == 0 pour cette app (appareil utilisé)."""
try:
val, _ = winreg.QueryValueEx(key, "LastUsedTimeStop")
return val == 0
except OSError:
return False
def _read_consent(device: str) -> list[str]:
procs = []
key_path = rf"SOFTWARE\Microsoft\Windows\CurrentVersion\CapabilityAccessManager\ConsentStore\{device}"
try:
with winreg.OpenKey(winreg.HKEY_CURRENT_USER, key_path) as key:
i = 0
while True:
try:
sub = winreg.EnumKey(key, i)
i += 1
except OSError:
break
try:
if sub == "NonPackaged":
# EN: Desktop apps — one sub-key per exe path.
# FR: Apps bureau — une sous-clé par chemin d'exe.
with winreg.OpenKey(key, sub) as np_key:
j = 0
while True:
try:
app = winreg.EnumKey(np_key, j)
j += 1
with winreg.OpenKey(np_key, app) as app_key:
if _key_in_use(app_key):
procs.append(app.split("#")[-1])
except OSError:
break
else:
# EN: Packaged (Store/UWP) apps sit directly under
# the capability key.
# FR: Les apps packagées (Store/UWP) sont
# directement sous la clé de capacité.
with winreg.OpenKey(key, sub) as app_key:
if _key_in_use(app_key):
procs.append(sub)
except OSError:
# EN: One broken key must not abort the whole walk.
# FR: Une clé cassée ne doit pas interrompre le parcours.
continue
except OSError:
pass
return procs
state.mic = _read_consent("microphone")
state.camera = _read_consent("webcam")
return state
def _detect_linux() -> MediaState:
"""
EN: Heuristic — a process holding /dev/snd* uses audio; /dev/video* means
camera. Requires read access to other processes' fd lists.
FR: Heuristique — un processus qui tient /dev/snd* utilise l'audio ;
/dev/video* signifie caméra. Nécessite l'accès en lecture aux
descripteurs de fichiers des autres processus.
"""
state = MediaState()
try:
for proc in psutil.process_iter(['name', 'open_files']):
try:
for f in proc.open_files():
if '/dev/snd' in f.path or '/dev/audio' in f.path:
if proc.name() not in state.mic:
state.mic.append(proc.name())
if '/dev/video' in f.path:
if proc.name() not in state.camera:
state.camera.append(proc.name())
except (psutil.NoSuchProcess, psutil.AccessDenied):
pass
except Exception as exc:
logger.debug("linux media scan failed: %s", exc)
return state
def detect_media_usage() -> MediaState:
"""
EN: Platform dispatch. macOS has no straightforward API for this — the
Linux branch would be wrong there, so we report "unsupported" and let
the UI hide the feature.
FR: Répartition selon la plateforme. macOS n'offre pas d'API simple pour
cela — la branche Linux y serait fausse, donc on rapporte
« non supporté » et l'UI masque la fonctionnalité.
"""
if sys.platform == "win32":
return _detect_windows()
if sys.platform == "darwin":
return MediaState(supported=False)
return _detect_linux()
class MediaMonitor:
"""
EN: Poll-based watcher. The callback fires only on CHANGE — same state
twice in a row produces no event.
FR: Observateur par sondage. Le callback ne se déclenche qu'en cas de
CHANGEMENT — deux états identiques d'affilée ne produisent rien.
"""
def __init__(self, callback: Callable[[MediaState], None], interval: int = 3):
self.callback = callback
self.interval = interval
self._running = False
self._last: MediaState | None = None
def start(self) -> None:
"""EN: Blocking loop — run inside a daemon thread.
FR: Boucle bloquante — à lancer dans un thread daemon."""
self._running = True
while self._running:
try:
state = detect_media_usage()
if self._last is None or state.mic != self._last.mic or state.camera != self._last.camera:
self._last = state
self.callback(state)
except Exception as exc:
logger.debug("media detect failed: %s", exc)
time.sleep(self.interval)
def stop(self) -> None:
"""EN: Stop the polling loop. / FR: Arrêter la boucle de sondage."""
self._running = False