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
Wire v1.5 features end-to-end and fix real bugs
MoneyLisa3dcbfe64df46
diff --git a/CHANGELOG.de.md b/CHANGELOG.de.mdindex acd9c3f..3f14263 100644--- a/CHANGELOG.de.md+++ b/CHANGELOG.de.md@@ -6,6 +6,23 @@ Alle nennenswerten Änderungen an Snitch.Das Format folgt [Keep a Changelog](https://keepachangelog.com/).+## [1.5.0] — 2026-10-22++### Hinzugefügt++- **Passive TLS-Zertifikatsinspektion** — `capture/tlscert.py` reassembliert die Server-`Certificate`-Nachricht über TCP-Segmente (begrenzt 16 KiB/Flow) und liest den Blatt-DER: Issuer/Subject, Self-Signed-Flag, SANs, Validität → `TLS_CERT` bei Self-Signed oder SAN/SNI-Mismatch. TLS 1.3 wird ehrlich als unbeobachtbar gemeldet — kein MITM, keine Entschlüsselung.+- **ICMP-Tunnel-Heuristik** — wiederholte große Echo-Payloads (≥24 B, 3+ in 5 Min) → `ICMP_TUNNEL` (ptunnel/icmpsh-Signatur).+- **High-Entropy-Erkennung** — quasi-zufällige Payload-Köpfe (≥4,7 Bit/Byte) auf Klartext-Sockets → `HIGH_ENTROPY` (verdeckte Krypto/Stego-Hinweis).+- **Isolation Forest (pur Python)** — `detection/iforest.py` + `mlflow.py` scoren Ausgangsflüsse auf 6 Features; `ML_ANOMALY` ab Score 0,62, inert unter 384 gelernten Flüssen.+- **Ask-on-Connect (Linux NFQUEUE, opt-in)** — `ask_enabled` hält neue Ausgangsflüsse in Queue 7 bis zu `POST /security/ask/verdict` — echte Verdict-Macht, Timeout droppt standardmäßig.+- **eBPF-Egress-Enforcement** — `detection/ebpf_enforce.py` + `POST /security/ebpf/isolate|block` — Kernel-Drops nur für Prozesse im snitch-Cgroup.+- **Hollowing-Beweis** — `POST /security/hollow` diff't ausführbare RAM-Seiten gegen die Disk-Datei (Linux, `/proc`).+- **IOC-Peer-Sync** — `gossip_peers` + `gossip_enabled`: gesalzene Merkle-Pakete alle 5 Min an explizit gelistete Peers — nur Hash-Commitments, keine Discovery.+- **Syslog** — `syslog_addr` (UDP oder `tcp://`) leitet warning/critical-Alarme als RFC 3164 weiter — SIEM/Wazuh-Pfad.+- **Geo-Regeln + Auto-Block** — Custom Rules mit `asn`/`country` (lokale mmdb) und `action:"block"` installieren echte Firewall-Regeln pro gematchter IP.+- **Actionable Alerts + Settings-UI** — Block IP / Kill / Suspend / Allow-Deny pro Alarm; neue Regler in den Einstellungen (syslog, ask, peers).+- **nftables-Backend + firejail** — `nft` wenn iptables fehlt (eigene `inet snitch`-Tabelle); `firejail --net=none` als Sandbox-Fallback.+## [Unreleased]### Hinzugefügtdiff --git a/CHANGELOG.es.md b/CHANGELOG.es.mdindex 3abb45e..8e98f1c 100644--- a/CHANGELOG.es.md+++ b/CHANGELOG.es.md@@ -6,6 +6,23 @@ Todos los cambios notables de Snitch.El formato sigue [Keep a Changelog](https://keepachangelog.com/).+## [1.5.0] — 2026-10-22++### Añadido++- **Inspección pasiva del certificado TLS** — `capture/tlscert.py` reensambla el mensaje `Certificate` del servidor a través de segmentos TCP (limitado a 16 KiB/flujo) y lee el DER hoja: emisor/sujeto, flag autofirmado, SANs, validez → `TLS_CERT` si autofirmado o mismatch SAN/SNI. TLS 1.3 se reporta honestamente como inobservable — sin MITM, sin descifrado.+- **Heurística de túnel ICMP** — ecos repetidos con payloads grandes (≥24 B, 3+ en 5 min) → `ICMP_TUNNEL` (firma ptunnel/icmpsh).+- **Detección de alta entropía** — cabeceras de payload casi aleatorias (≥4,7 bits/byte) en sockets en claro → `HIGH_ENTROPY` (indicio de cifrado encubierto/estego).+- **Isolation Forest (Python puro)** — `detection/iforest.py` + `mlflow.py` puntúan flujos salientes con 6 features; `ML_ANOMALY` a partir de score 0,62, inerte bajo 384 flujos aprendidos.+- **Ask-on-connect (Linux NFQUEUE, opt-in)** — `ask_enabled` retiene nuevos flujos salientes en la cola 7 hasta `POST /security/ask/verdict` — veredicto real, el timeout droppea por defecto.+- **Enforcement eBPF de egress** — `detection/ebpf_enforce.py` + `POST /security/ebpf/isolate|block` — drops en kernel solo para procesos del cgroup snitch.+- **Prueba de hollowing** — `POST /security/hollow` compara páginas ejecutables en RAM con el fichero en disco (Linux, `/proc`).+- **Sincronización IOC entre pares** — `gossip_peers` + `gossip_enabled`: paquetes Merkle salados cada 5 min a pares explícitamente listados — solo compromisos hash, sin discovery.+- **Syslog** — `syslog_addr` (UDP o `tcp://`) reenvía alertas warning/críticas como RFC 3164 — camino SIEM/Wazuh.+- **Reglas geo + auto-bloqueo** — reglas custom con `asn`/`country` (mmdb local) y `action:"block"` instalan reglas de firewall reales por IP coincidente.+- **Alertas accionables + UI de ajustes** — Bloquear IP / Matar / Suspender / Permitir-Denegar por alerta; nuevos controles en ajustes (syslog, ask, pares).+- **Backend nftables + firejail** — `nft` cuando falta iptables (tabla `inet snitch` dedicada); `firejail --net=none` como fallback de sandbox.+## [Unreleased]### Añadidodiff --git a/CHANGELOG.ja.md b/CHANGELOG.ja.mdindex d569949..790006e 100644--- a/CHANGELOG.ja.md+++ b/CHANGELOG.ja.md@@ -6,6 +6,23 @@ Snitch の全ての注目すべき変更。フォーマットは [Keep a Changelog](https://keepachangelog.com/) に準拠。+## [1.5.0] — 2026-10-22++### 追加++- **パッシブTLS証明書インスペクション** — `capture/tlscert.py` がサーバーの `Certificate` メッセージをTCPセグメント越しに再構成(16 KiB/フロー上限)し、リーフDERを読み取り:発行者/サブジェクト、自己署名フラグ、SAN、有効期限 → 自己署名やSAN/SNI不一致で `TLS_CERT`。TLS 1.3は正直に「観測不可」と報告 — MITMも復号もなし。+- **ICMPトンネル検知** — 大きなエコーペイロードの繰り返し(≥24B、5分で3回以上)→ `ICMP_TUNNEL`(ptunnel/icmpshシグネチャ)。+- **高エントロピー検知** — 平文ソケット上のほぼランダムなペイロード先頭(≥4.7ビット/バイト)→ `HIGH_ENTROPY`(秘匿暗号/ステガノの兆候)。+- **Isolation Forest(純Python)** — `detection/iforest.py` + `mlflow.py` が送信フローを6特徴量でスコアリング;スコア0.62以上で `ML_ANOMALY`、学習384フロー未満では不活性。+- **Ask-on-Connect(Linux NFQUEUE、オプトイン)** — `ask_enabled` が新規送信フローをキュー7に保留し `POST /security/ask/verdict` まで保持 — 本物の判定権、タイムアウトは既定でdrop。+- **eBPF egressエンフォースメント** — `detection/ebpf_enforce.py` + `POST /security/ebpf/isolate|block` — snitch cgroup内のプロセスのみカーネルdrop。+- **ハロウィング証拠** — `POST /security/hollow` が実行可能RAMページとディスク上ファイルを比較(Linux、`/proc`)。+- **IOCピア同期** — `gossip_peers` + `gossip_enabled`:塩付きMerkleパックを5分毎に明示リストのピアへ — ハッシュコミットメントのみ、探索なし。+- **Syslog** — `syslog_addr`(UDPまたは `tcp://`)が警告/重大アラートをRFC 3164で転送 — SIEM/Wazuh経路。+- **ジオルール + 自動ブロック** — カスタムルールの `asn`/`country`(ローカルmmdb)と `action:"block"` が一致IPへ実ファイアウォールルールを追加。+- **アクション可能アラート + 設定UI** — アラート毎にIPブロック/強制終了/一時停止/許可・拒否;設定画面に新コントロール(syslog、ask、ピア)。+- **nftablesバックエンド + firejail** — iptables不在時は `nft`(専用 `inet snitch` テーブル);`firejail --net=none` をサンドボックスのフォールバックに。+## [Unreleased]### 追加diff --git a/CHANGELOG.md b/CHANGELOG.mdindex baf5ec1..1aad430 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -23,12 +23,17 @@ The format follows [Keep a Changelog](https://keepachangelog.com/) — EN/FR.- **Actionable alerts / Alertes actionnables** — alert details now carry `pid`/`process`; the UI offers one-click **Block IP** (real firewall rule), **Kill**, **Suspend**, and ASK_VERDICT **Allow/Deny** buttons; explanation templates gained remediation actions for all new types. / Les alertes portent `pid`/`process` ; l'UI propose Bloquer IP, Tuer, Suspendre et Autoriser/Refuser ; gabarits d'explication avec actions de remédiation.- **nftables backend / Backend nftables** — Linux firewall rules, lockdown, IP-sinkhole DNAT and domain refresh now drive `nft` directly when iptables is absent (dedicated `inet snitch` table, comment-tagged handle cleanup); per-process rules refuse honestly (no PID owner match in nft). / Règles, lockdown, DNAT sinkhole et refresh domaine pilotent `nft` quand iptables est absent ; les règles par processus refusent honnêtement.- **firejail sandbox fallback / Repli firejail** — Linux containment falls back to `firejail --net=none --quiet` when `unshare` is unavailable; `available()` reports which backend it will use. / Repli `firejail --net=none` quand `unshare` est absent ; `available()` rapporte le backend choisi.+- **Settings UI for the new opt-ins / Réglages UI des nouveaux opt-ins** — syslog address, ask-on-connect (timeout + fail-open + live availability), IOC peer list + periodic toggle are all editable in Settings; `ask_timeout`/`ask_failopen`/`gossip_enabled` apply live. / Adresse syslog, ask-on-connect (timeout + fail-open + dispo en direct), liste de pairs IOC + bascule périodique — tous éditables dans les Réglages ; appliqués à chaud.+- **Periodic IOC push / Push IOC périodique** — `gossip_enabled` re-pushes your salted-Merkle proof pack to configured peers every 5 min automatically (was manual-endpoint only). / `gossip_enabled` repousse le paquet Merkle salé toutes les 5 min (avant : endpoint manuel seul).+- **eBPF enforcer endpoints / Endpoints enforceur eBPF** — `GET /security/ebpf_enforce`, `POST /security/ebpf/isolate {pid}`, `POST /security/ebpf/block {ip}` wire the cgroup-skb enforcer into the API (lazy start, honest failure). / Le enforcer cgroup-skb exposé : statut + isolation de pid + blocage d'IP (démarrage paresseux, échec honnête).+- **Variance-aware iForest splits / Splits iForest à variance réelle** — trees now only split on features with variance in the subset (constant columns produced degenerate fat leaves that compressed every score toward 0.5) and draw a fresh subsample per tree — measurably better contrast between baseline and outliers. / Les arbres ne splittent que sur les features à variance réelle (les colonnes constantes compressaient les scores vers 0,5) + sous-échantillon frais par arbre — contraste mesurablement meilleur.### Fixed / Corrigé- **Real-OS integration tests / Tests d'intégration OS réels** — new `integration` CI job (per-OS) running `tests/test_integration_os.py` with `SNITCH_OS_INTEGRATION=1`: Linux proves `unshare -n` egress denial, real `iptables` DROP + live connect failure, `tc` clsact/flower, `perf_event_open`; Windows opens the real `fwpuclnt` engine and proves a WFP BLOCK filter with a TCP connect that fails then recovers after key-delete; macOS proves `sandbox-exec` deny-network end-to-end and hosts-file sinkhole apply/remove. Every test cleans up in `finally` and skips honestly when the primitive is unavailable. / Nouveau job CI `integration` par OS exécutant `tests/test_integration_os.py` : `unshare`, `iptables` réels + connexion probée, `tc`, `perf` sous Linux ; moteur WFP + blocage prouvé par connexion TCP sous Windows ; `sandbox-exec` + hosts sous macOS. Nettoyage en `finally`, skip honnête si la primitive manque.- **WFP filter enums + byte order / Enums WFP + ordre des octets** — real Windows CI caught `FWP_DATA_TYPE` constants off-by-N (`BYTE_ARRAY16`=11, `BYTE_BLOB`=12, composite addr-mask types at 0x100/0x101) and host-order IPv4 encoding in `FWP_V4_ADDR_AND_MASK` (must be network order); filters now actually match traffic on real Windows. / La CI Windows réelle a attrapé des constantes `FWP_DATA_TYPE` décalées et un encodage IPv4 host-order — les filtres matchent maintenant réellement.- **perfprobe Windows import / Import perfprobe Windows** — `fcntl` is now imported lazily inside the Linux path instead of top-level (collection crash on Windows). / `fcntl` importé paresseusement dans le chemin Linux (crash de collecte sous Windows).+- **eBPF attach scope / Portée de l'attach eBPF** — the cgroup-skb program attached at the cgroup2 *root*, which would have made every blocked-IP drop host-wide; it now attaches to the dedicated `snitch` cgroup so drops apply only to `isolate_pid()`-moved processes, as documented. / Le programme cgroup-skb s'attachait à la racine cgroup2 — chaque blocage aurait été global ; il s'attache au cgroup `snitch` dédié, drops limités aux processus isolés, comme documenté.## [1.4.0] — 2026-10-23diff --git a/CHANGELOG.pt-BR.md b/CHANGELOG.pt-BR.mdindex 3a1c85c..fb86c47 100644--- a/CHANGELOG.pt-BR.md+++ b/CHANGELOG.pt-BR.md@@ -6,6 +6,23 @@ Todas as mudanças notáveis do Snitch.O formato segue o [Keep a Changelog](https://keepachangelog.com/).+## [1.5.0] — 2026-10-22++### Adicionado++- **Inspeção passiva do certificado TLS** — `capture/tlscert.py` remonta a mensagem `Certificate` do servidor através de segmentos TCP (limite 16 KiB/fluxo) e lê o DER folha: emissor/sujeito, flag autoassinado, SANs, validade → `TLS_CERT` se autoassinado ou mismatch SAN/SNI. TLS 1.3 é reportado honestamente como inobservável — sem MITM, sem decriptação.+- **Heurística de túnel ICMP** — ecos repetidos com payloads grandes (≥24 B, 3+ em 5 min) → `ICMP_TUNNEL` (assinatura ptunnel/icmpsh).+- **Detecção de alta entropia** — cabeças de payload quase aleatórias (≥4,7 bits/byte) em sockets em claro → `HIGH_ENTROPY` (indício de cripto encoberta/estego).+- **Isolation Forest (Python puro)** — `detection/iforest.py` + `mlflow.py` pontuam fluxos de saída em 6 features; `ML_ANOMALY` a partir de score 0,62, inerte abaixo de 384 fluxos aprendidos.+- **Ask-on-connect (Linux NFQUEUE, opt-in)** — `ask_enabled` retém novos fluxos de saída na fila 7 até `POST /security/ask/verdict` — veredito real, timeout dropa por padrão.+- **Enforcement eBPF de egress** — `detection/ebpf_enforce.py` + `POST /security/ebpf/isolate|block` — drops em kernel apenas para processos no cgroup snitch.+- **Prova de hollowing** — `POST /security/hollow` compara páginas executáveis em RAM com o ficheiro em disco (Linux, `/proc`).+- **Sincronização IOC entre pares** — `gossip_peers` + `gossip_enabled`: pacotes Merkle com sal a cada 5 min para pares explicitamente listados — só compromissos hash, sem discovery.+- **Syslog** — `syslog_addr` (UDP ou `tcp://`) encaminha alertas warning/críticos como RFC 3164 — caminho SIEM/Wazuh.+- **Regras geo + auto-bloqueio** — regras custom com `asn`/`country` (mmdb local) e `action:"block"` instalam regras de firewall reais por IP correspondido.+- **Alertas acionáveis + UI de ajustes** — Bloquear IP / Matar / Suspender / Permitir-Negar por alerta; novos controles nos ajustes (syslog, ask, pares).+- **Backend nftables + firejail** — `nft` quando falta iptables (tabela `inet snitch` dedicada); `firejail --net=none` como fallback de sandbox.+## [Unreleased]### Adicionadodiff --git a/CHANGELOG.ru.md b/CHANGELOG.ru.mdindex 83e1a96..f1e6969 100644--- a/CHANGELOG.ru.md+++ b/CHANGELOG.ru.md@@ -6,6 +6,23 @@Формат следует [Keep a Changelog](https://keepachangelog.com/).+## [1.5.0] — 2026-10-22++### Добавлено++- **Пассивная инспекция TLS-сертификата** — `capture/tlscert.py` собирает сообщение `Certificate` сервера из TCP-сегментов (лимит 16 КиБ/поток) и читает DER листа: издатель/субъект, флаг самоподписи, SAN, срок → `TLS_CERT` при самоподписи или mismatch SAN/SNI. TLS 1.3 честно помечается ненаблюдаемым — без MITM и расшифровки.+- **Эвристика ICMP-туннеля** — повторные объёмные echo-пayloads (≥24 Б, 3+ за 5 мин) → `ICMP_TUNNEL` (сигнатура ptunnel/icmpsh).+- **Детект высокой энтропии** — почти случайные головы payload (≥4,7 бит/байт) на открытых сокетах → `HIGH_ENTROPY` (признак скрытого шифрования/стего).+- **Isolation Forest (чистый Python)** — `detection/iforest.py` + `mlflow.py` скорят исходящие потоки по 6 признакам; `ML_ANOMALY` при score ≥0,62, неактивно до 384 выученных потоков.+- **Ask-on-connect (Linux NFQUEUE, opt-in)** — `ask_enabled` удерживает новые исходящие потоки в очереди 7 до `POST /security/ask/verdict` — настоящий вердикт, таймаут по умолчанию дропает.+- **eBPF egress-эндфорсмент** — `detection/ebpf_enforce.py` + `POST /security/ebpf/isolate|block` — дропы в ядре только для процессов в cgroup snitch.+- **Доказательство hollowing** — `POST /security/hollow` сравнивает исполняемые страницы в RAM с файлом на диске (Linux, `/proc`).+- **Синхронизация IOC с пирами** — `gossip_peers` + `gossip_enabled`: солёные Merkle-пакеты каждые 5 мин явно перечисленным пирам — только хеш-коммитменты, без discovery.+- **Syslog** — `syslog_addr` (UDP или `tcp://`) пересылает алерты warning/critical как RFC 3164 — путь в SIEM/Wazuh.+- **Гео-правила + автоблок** — свои правила с `asn`/`country` (локальная mmdb) и `action:"block"` ставят настоящие правила фаервола на каждый совпавший IP.+- **Действующие алерты + UI настроек** — Блок IP / Убить / Приостановить / Разрешить-Запретить на каждый алерт; новые элементы в настройках (syslog, ask, пиры).+- **Backend nftables + firejail** — `nft` при отсутствии iptables (отдельная таблица `inet snitch`); `firejail --net=none` как фолбэк песочницы.+## [Unreleased]### Добавленоdiff --git a/CHANGELOG.zh-CN.md b/CHANGELOG.zh-CN.mdindex 9cc815e..4b044b7 100644--- a/CHANGELOG.zh-CN.md+++ b/CHANGELOG.zh-CN.md@@ -6,6 +6,23 @@ Snitch 的所有重要变更。格式遵循 [Keep a Changelog](https://keepachangelog.com/)。+## [1.5.0] — 2026-10-22++### 新增++- **被动 TLS 证书检查** — `capture/tlscert.py` 跨 TCP 分段重组服务器 `Certificate` 消息(每流 16 KiB 上限)并读取叶子 DER:签发者/主体、自签名标记、SAN、有效期 → 自签名或 SAN/SNI 不匹配时触发 `TLS_CERT`。TLS 1.3 诚实报告为不可观测 — 无 MITM、无解密。+- **ICMP 隧道启发式** — 反复出现的大载荷回显(≥24 B,5 分钟内 3 次以上)→ `ICMP_TUNNEL`(ptunnel/icmpsh 特征)。+- **高熵检测** — 明文套接字上接近随机的载荷头部(≥4.7 比特/字节)→ `HIGH_ENTROPY`(隐蔽加密/隐写迹象)。+- **Isolation Forest(纯 Python)** — `detection/iforest.py` + `mlflow.py` 用 6 个特征为出站流打分;score ≥0.62 触发 `ML_ANOMALY`,学习不足 384 流时保持惰性。+- **Ask-on-connect(Linux NFQUEUE,可选)** — `ask_enabled` 将新出站流挂入队列 7 直到 `POST /security/ask/verdict` — 真实判定权,超时默认丢弃。+- **eBPF 出站执行** — `detection/ebpf_enforce.py` + `POST /security/ebpf/isolate|block` — 仅对 snitch cgroup 内进程进行内核级丢弃。+- **空心化证据** — `POST /security/hollow` 对比 RAM 中可执行页与磁盘文件(Linux,`/proc`)。+- **IOC 节点同步** — `gossip_peers` + `gossip_enabled`:每 5 分钟向显式列出的节点推送加盐 Merkle 包 — 仅哈希承诺,无发现机制。+- **Syslog** — `syslog_addr`(UDP 或 `tcp://`)以 RFC 3164 转发警告/严重告警 — SIEM/Wazuh 路径。+- **地理规则 + 自动封锁** — 自定义规则支持 `asn`/`country`(本地 mmdb)与 `action:"block"`,为每个匹配 IP 安装真实防火墙规则。+- **可操作告警 + 设置界面** — 每条告警提供封锁 IP / 终止 / 挂起 / 允许-拒绝;设置中新增控件(syslog、ask、节点)。+- **nftables 后端 + firejail** — 无 iptables 时使用 `nft`(专用 `inet snitch` 表);`firejail --net=none` 作为沙箱回退。+## [Unreleased]### 新增diff --git a/PRIVACY.de.md b/PRIVACY.de.mdindex 942c8e9..1f2f35c 100644--- a/PRIVACY.de.md+++ b/PRIVACY.de.md@@ -84,3 +84,11 @@ Windows, `~/Library/Application Support/Snitch` unter macOS,- **Sandbox ohne Netzwerk** — `POST /security/sandbox` führt eine Binärdatei in einem netzlosen Namespace (`unshare -n` Linux) bzw. Seatbelt-Profil (`sandbox-exec` macOS) aus: null Egress, Ausgabe bleibt lokal.- **IOC `format=proof`** — gesalzene SHA-256-Blätter + Merkle-Wurzel: exakte Mitgliedschaft ohne Aufzählung unverdächtiger Indikatoren; nichts wird automatisch übertragen.- **Eingebettetes Modell** — `slm_mode=embedded` lädt Ihr `.gguf` im Prozess via `llama-cpp-python` — null Netzwerk; Snitch lädt nie Gewichte herunter.++## Neu in v1.5 (Privatsphäre)++- **Syslog-Ausgabe (opt-in, aus)** — `syslog_addr` (`host:port` UDP oder `tcp://host:port`) leitet warning/critical-Alarmtexte als RFC-3164-Datagramme an Ihren SIEM — ein echter ausgehender Fluss zur konfigurierten Adresse, unabhängig vom Webhook-Schalter.+- **IOC-Peer-Sync (opt-in, aus)** — `gossip_peers` (explizite Liste von Snitch-Backends unter Ihrer Kontrolle) lässt `POST /remote/ioc_sync` Ihr gesalzenes Merkle-Proof-Paket an deren authentifizierten Import-Endpunkt pushen — NUR das Paket (Hash-Commitments, nie rohe Indikatoren, Hostnamen oder Pfade). `gossip_enabled` wiederholt den Push alle 5 Minuten. Keine Discovery, nichts geht an ungelistete Adressen.+- **Passive TLS-Zertifikatslektüre bleibt auf der Leitung** — der Handshake-Watcher liest die Certificate-Nachricht *des Servers* im Klartext — kein Abfangen, kein Einfügen, kein Entschlüsseln. TLS 1.3 verschlüsselt diese Nachricht, was wir ehrlich als unbeobachtbar melden. Metadaten (Issuer, Subject, SANs) speisen nur lokale Anomalie-Checks und werden nie als rohe Zertifikatsbytes persistiert.+- **Ask-on-Connect (opt-in)** — `ask_enabled` hält neue Ausgangsflüsse lokal in NFQUEUE 7, bis Sie urteilen; Timeout droppt standardmäßig. Es ist ein Verdict, kein Relay — nichts wird dadurch ins Netz gesendet.+- **eBPF-Enforcement & Hollow-Check** — laufen vollständig im Kernel bzw. `/proc` der eigenen Maschine; Ergebnisse bleiben lokal.diff --git a/PRIVACY.es.md b/PRIVACY.es.mdindex a333492..e315c28 100644--- a/PRIVACY.es.md+++ b/PRIVACY.es.md@@ -85,3 +85,11 @@ Windows, `~/Library/Application Support/Snitch` en macOS,- **Sandbox sin red** — `POST /security/sandbox` ejecuta un binario en un namespace sin red (`unshare -n` Linux) o seatbelt (`sandbox-exec` macOS): egress cero, la salida queda en la máquina.- **Pruebas IOC `format=proof`** — hojas SHA-256 saladas + raíz Merkle: pertenencia exacta sin enumerar indicadores no sospechados; nada se transmite automáticamente.- **Modelo embebido** — `slm_mode=embedded` carga tu `.gguf` en proceso vía `llama-cpp-python` — cero red; Snitch nunca descarga pesos.++## Novedades v1.5 (privacidad)++- **Salida syslog (opt-in, desactivada)** — `syslog_addr` (`host:puerto` UDP o `tcp://host:puerto`) reenvía los textos de alertas warning/críticas como datagramas RFC 3164 a tu SIEM — un flujo saliente real a la dirección configurada, independiente del webhook.+- **Sincronización IOC entre pares (opt-in, desactivada)** — `gossip_peers` (lista explícita de backends Snitch que controlas) permite a `POST /remote/ioc_sync` empujar tu paquete Merkle salado a su endpoint de importación autenticado — SOLO ese paquete (compromisos hash, nunca indicadores crudos, hostnames o rutas). `gossip_enabled` repite el push cada 5 min. Sin discovery, nada sale a direcciones no listadas.+- **La lectura pasiva del certificado TLS queda en el cable** — el watcher de handshake lee el mensaje Certificate *del propio servidor* en claro — sin intercepción, inyección ni descifrado. TLS 1.3 cifra ese mensaje, lo reportamos honestamente como inobservable. Los metadatos (emisor, sujeto, SANs) solo alimentan checks locales y nunca se persisten como bytes crudos.+- **Ask-on-connect (opt-in)** — `ask_enabled` retiene nuevos flujos salientes localmente en NFQUEUE 7 hasta tu veredicto; el timeout droppea por defecto. Es un veredicto, no un relay — nada sale a la red por ello.+- **Enforcement eBPF y check de hollowing** — corren enteramente en el kernel o `/proc` de tu máquina; sus resultados se quedan en local.diff --git a/PRIVACY.ja.md b/PRIVACY.ja.mdindex a810208..57a666b 100644--- a/PRIVACY.ja.md+++ b/PRIVACY.ja.md@@ -84,3 +84,11 @@ Linux はインストール時 `~/.local/share/snitch`。- **ネットワーク遮断サンドボックス** — `POST /security/sandbox` がバイナリをネットワークなしの名前空間(Linux `unshare -n`)または seatbelt(macOS `sandbox-exec`)で実行:送信ゼロ、出力はマシン内に留まります。- **IOC `format=proof`** — ソルト付き SHA-256 リーフ+Merkle ルート:疑っていない指標を列挙させずに厳密な所属証明;自動送信は一切なし。- **埋め込みモデル** — `slm_mode=embedded` がユーザーの `.gguf` を `llama-cpp-python` でプロセス内に読み込み — ネットワーク完全ゼロ;Snitch が重みをダウンロードすることはありません。++## v1.5 の新機能(プライバシー)++- **Syslog出力(オプトイン、既定オフ)** — `syslog_addr`(UDP `host:port` または `tcp://host:port`)が警告/重大アラート本文をRFC 3164データグラムとしてSIEMへ転送 — 設定アドレスへの実際の送信フローで、Webhookスイッチとは独立。+- **IOCピア同期(オプトイン、既定オフ)** — `gossip_peers`(管理下のSnitchバックエンドの明示リスト)で `POST /remote/ioc_sync` があなたの塩付きMerkleプルーフパックを相手の認証済みインポートendpointへプッシュ — そのパックのみ(ハッシュコミットメント、生インジケーター・ホスト名・パスは送信しません)。`gossip_enabled` で5分毎に自動プッシュ。探索なし、未登録アドレスには一切送信しません。+- **パッシブTLS証明書リードは線路上に留まる** — ハンドシェイク監視は*サーバー自身の* Certificateメッセージを平文のまま読むだけ — 傍受・注入・復号なし。TLS 1.3はこのメッセージを暗号化するため、正直に「観測不可」と報告します。メタデータ(発行者・サブジェクト・SAN)はローカル異常チェックのみに使われ、生の証明書バイトとして永続化されません。+- **Ask-on-Connect(オプトイン)** — `ask_enabled` が新規送信フローをローカルのNFQUEUE 7に判定まで保留;タイムアウトは既定でdrop。判定でありリレーではありません — これ自体が何かをネットワークへ送ることはありません。+- **eBPFエンフォースメント & ハロウィングチェック** — 完全に自マシンのカーネル/`/proc` 内で動作;結果はローカルに留まります。diff --git a/PRIVACY.md b/PRIVACY.mdindex 696d23d..397fb63 100644--- a/PRIVACY.md+++ b/PRIVACY.md@@ -51,8 +51,10 @@ webhook switch.of explicit Snitch backend URLs you control) lets `POST /remote/ioc_sync`push your salted-Merkle proof pack to those peers' authenticated importendpoint — and ONLY that pack (hash commitments, never raw indicators,-never hostnames or paths). Peers must be operator-listed; there is no-discovery and nothing is ever sent to an unlisted address.+never hostnames or paths). Setting `gossip_enabled` additionally pushes+the same pack automatically every 5 minutes. Peers must be+operator-listed; there is no discovery and nothing is ever sent to an+unlisted address.**Passive TLS certificate reading stays on the wire.** The handshakewatcher reads the *server's own* Certificate message in cleartext —@@ -176,8 +178,10 @@ l'interrupteur webhook.contrôlez) permet à `POST /remote/ioc_sync` de pousser votre paquetMerkle salé vers l'endpoint d'import authentifié de ces pairs — etUNIQUEMENT ce paquet (engagements de hash, jamais d'indicateurs en-clair, jamais de noms d'hôte ni de chemins). Les pairs doivent être-listés par l'opérateur ; aucune découverte, rien n'est jamais envoyé+clair, jamais de noms d'hôte ni de chemins). `gossip_enabled` pousse en+plus le même paquet automatiquement toutes les 5 minutes. Les pairs+doivent être listés par l'opérateur ; aucune découverte, rien n'est+jamais envoyéà une adresse non listée.**La lecture passive des certificats TLS reste sur le fil.** L'observateurdiff --git a/PRIVACY.pt-BR.md b/PRIVACY.pt-BR.mdindex cf1ddd5..bbde18a 100644--- a/PRIVACY.pt-BR.md+++ b/PRIVACY.pt-BR.md@@ -86,3 +86,11 @@ Windows, `~/Library/Application Support/Snitch` no macOS,- **Sandbox sem rede** — `POST /security/sandbox` executa um binário num namespace sem rede (`unshare -n` Linux) ou seatbelt (`sandbox-exec` macOS): egress zero, a saída fica na máquina.- **IOC `format=proof`** — folhas SHA-256 com sal + raiz Merkle: pertinência exata sem enumerar indicadores não suspeitos; nada é transmitido automaticamente.- **Modelo embutido** — `slm_mode=embedded` carrega seu `.gguf` em processo via `llama-cpp-python` — zero rede; Snitch nunca baixa pesos.++## Novidades v1.5 (privacidade)++- **Saída syslog (opt-in, desativada)** — `syslog_addr` (`host:porta` UDP ou `tcp://host:porta`) encaminha textos de alertas warning/críticos como datagramas RFC 3164 ao seu SIEM — um fluxo de saída real para o endereço configurado, independente do webhook.+- **Sincronização IOC entre pares (opt-in, desativada)** — `gossip_peers` (lista explícita de backends Snitch que você controla) permite ao `POST /remote/ioc_sync` enviar seu pacote Merkle com sal ao endpoint de importação autenticado deles — APENAS esse pacote (compromissos hash, nunca indicadores brutos, hostnames ou caminhos). `gossip_enabled` repete o envio a cada 5 min. Sem discovery, nada sai para endereços não listados.+- **A leitura passiva do certificado TLS fica no fio** — o watcher de handshake lê a mensagem Certificate *do próprio servidor* em claro — sem interceptação, injeção ou decriptação. O TLS 1.3 cifra essa mensagem, o que reportamos honestamente como inobservável. Metadados (emissor, sujeito, SANs) só alimentam checagens locais e nunca são persistidos como bytes brutos.+- **Ask-on-connect (opt-in)** — `ask_enabled` retém novos fluxos de saída localmente na NFQUEUE 7 até seu veredito; o timeout dropa por padrão. É um veredito, não um relay — nada vai para a rede por causa disso.+- **Enforcement eBPF e check de hollowing** — rodam inteiramente no kernel/`/proc` da sua máquina; os resultados ficam locais.diff --git a/PRIVACY.ru.md b/PRIVACY.ru.mdindex 143b894..f9eb000 100644--- a/PRIVACY.ru.md+++ b/PRIVACY.ru.md@@ -85,3 +85,11 @@ Linux при установленном запуске.- **Песочница без сети** — `POST /security/sandbox` запускает бинарник в namespace без сети (`unshare -n` Linux) или seatbelt (`sandbox-exec` macOS): нулевой egress, вывод остаётся на машине.- **IOC `format=proof`** — засоленные листья SHA-256 + корень Merkle: точное членство без перечисления неподозреваемых индикаторов; ничего не передаётся автоматически.- **Встроенная модель** — `slm_mode=embedded` загружает ваш `.gguf` в процесс через `llama-cpp-python` — ноль сети; Snitch никогда не скачивает веса.++## Новое в v1.5 (приватность)++- **Вывод syslog (opt-in, выкл.)** — `syslog_addr` (`хост:порт` UDP или `tcp://хост:порт`) пересылает тексты алертов warning/critical как датаграммы RFC 3164 в ваш SIEM — настоящий исходящий поток на заданный адрес, независимо от вебхука.+- **Синхронизация IOC с пирами (opt-in, выкл.)** — `gossip_peers` (явный список backend'ов Snitch под вашим контролем) позволяет `POST /remote/ioc_sync` отправлять ваш солёный Merkle-пакет на их аутентифицированный endpoint импорта — ТОЛЬКО этот пакет (хеш-коммитменты, никогда сырые индикаторы, имена хостов или пути). `gossip_enabled` повторяет отправку каждые 5 мин. Без discovery, ничего не уходит неперечисленным адресам.+- **Пассивное чтение TLS-сертификата остаётся на проводе** — watcher хендшейка читает сообщение Certificate *самого сервера* в открытом виде — без перехвата, внедрения и расшифровки. TLS 1.3 шифрует это сообщение, что мы честно помечаем ненаблюдаемым. Метаданные (издатель, субъект, SAN) идут только в локальные проверки и никогда не сохраняются как сырые байты.+- **Ask-on-connect (opt-in)** — `ask_enabled` удерживает новые исходящие потоки локально в NFQUEUE 7 до вашего вердикта; таймаут по умолчанию дропает. Это вердикт, а не ретранслятор — само по себе ничего не отправляет в сеть.+- **eBPF-эндфорсмент и проверка hollowing** — работают целиком в ядре/`/proc` вашей машины; результаты остаются локальными.diff --git a/PRIVACY.zh-CN.md b/PRIVACY.zh-CN.mdindex 0aa7e00..03c257f 100644--- a/PRIVACY.zh-CN.md+++ b/PRIVACY.zh-CN.md@@ -73,3 +73,11 @@ macOS 为 `~/Library/Application Support/Snitch`;Linux 安装后运行时为- **无网络沙箱** — `POST /security/sandbox` 在无网络的命名空间(Linux `unshare -n`)或 seatbelt(macOS `sandbox-exec`)中运行二进制:出站为零,输出留在本机。- **IOC `format=proof`** — 加盐 SHA-256 叶子 + Merkle 根:精确成员证明且无法枚举未怀疑的指标;绝不自动传输。- **内置模型** — `slm_mode=embedded` 通过 `llama-cpp-python` 在进程内加载您的 `.gguf` — 完全零网络;Snitch 从不下载权重。++## v1.5 新增(隐私)++- **Syslog 输出(可选,默认关闭)** — `syslog_addr`(UDP `主机:端口` 或 `tcp://主机:端口`)将警告/严重告警文本以 RFC 3164 数据报转发给您的 SIEM — 指向所配置地址的真实出站流,与 webhook 开关独立。+- **IOC 节点同步(可选,默认关闭)** — `gossip_peers`(您控制的 Snitch 后端显式列表)允许 `POST /remote/ioc_sync` 将您的加盐 Merkle 证明包推送到对方的认证导入端点 — 仅此包(哈希承诺,绝不包含原始指标、主机名或路径)。`gossip_enabled` 每 5 分钟自动推送一次。无发现机制,绝不发往未列出地址。+- **被动 TLS 证书读取不离开线路** — 握手观察器仅明文读取*服务器自己的* Certificate 消息 — 不拦截、不注入、不解密。TLS 1.3 会加密该消息,我们诚实报告为不可观测。元数据(签发者、主体、SAN)只用于本地异常检查,绝不以原始证书字节持久化。+- **Ask-on-connect(可选)** — `ask_enabled` 将新出站流保留在本地 NFQUEUE 7 直到您判定;超时默认丢弃。这是判定而非中继 — 它本身不向网络发送任何内容。+- **eBPF 执行与空心化检查** — 完全在本机内核/`/proc` 中运行;结果留在本地。diff --git a/backend/api/main.py b/backend/api/main.pyindex 4c928e4..eed7933 100644--- a/backend/api/main.py+++ b/backend/api/main.py@@ -103,6 +103,7 @@ from detection.llm_local import LocalSlmfrom detection.miner import MinerDetectorfrom detection.mlflow import FlowAnomalyfrom detection import askmode+from detection import ebpf_enforcefrom detection import hollow as hollowmodfrom detection.gossip import PeerSyncfrom detection import perfprobe@@ -180,6 +181,11 @@ def _ask_notify(ctx: dict) -> None:ask_mode = askmode.AskMode(_ask_notify)+# EN: cgroup-skb egress enforcer — lazy-started on first use; needs+# root + bcc + cgroup2 (status endpoint reports honestly).+# FR: Enforceur egress cgroup-skb — démarré paresseusement au premier+# usage ; exige root + bcc + cgroup2 (statut honnête).+ebpf_enforcer = ebpf_enforce.EbpfEnforcer()# EN: Dedup for custom-rule block actions — one firewall rule per# (rule_id, remote_ip), so a chatty flow doesn't pile up rules.# FR: Dédup des actions block des règles — une règle pare-feu par@@ -187,6 +193,11 @@ ask_mode = askmode.AskMode(_ask_notify)_rule_blocks: set[tuple] = set()_entropy_cooldown: dict[str, float] = {}_icmp_window: dict[str, list] = {}+# EN: IOC peer-sync cadence — fixed 5 min; activation is governed by the+# `gossip_enabled` setting, not by this constant.+# FR: Cadence de sync IOC — 5 min fixe ; l'activation relève du réglage+# `gossip_enabled`, pas de cette constante.+_GOSSIP_INTERVAL_S = 300_loop: asyncio.AbstractEventLoop | None = None_sniffer: PacketSniffer | None = None_scanner: ARPScanner | None = None@@ -1341,6 +1352,35 @@ async def _drain_loop() -> None:await asyncio.sleep(DRAIN_INTERVAL_S)+async def _gossip_loop() -> None:+ """EN: Periodic IOC peer sync — every 5 min, only while the operator+ opt-in (`gossip_enabled`) is set AND peers are configured. Pushes+ the salted-Merkle proof pack (hash commitments only, never raw+ indicators). Failures are logged, never raised.+ FR: Sync IOC périodique — toutes les 5 min, seulement si l'opt-in+ `gossip_enabled` est posé ET des pairs configurés. Pousse le+ paquet Merkle salé (engagements de hash, jamais d'indicateurs+ bruts). Les échecs sont loggés, jamais levés."""+ while not _shutdown:+ await asyncio.sleep(_GOSSIP_INTERVAL_S)+ if _shutdown:+ break+ try:+ if not db.get_setting("gossip_enabled", False):+ continue+ if not peer_sync.peers:+ continue+ loop = asyncio.get_running_loop()+ indicators = await loop.run_in_executor(+ None, _collect_indicators)+ pack = iocshare.build_proof_pack(indicators)+ res = await loop.run_in_executor(+ None, peer_sync.push_pack, pack)+ logger.info("ioc peer sync: %s", res)+ except Exception as exc: # noqa: BLE001+ logger.warning("ioc peer sync failed: %s", exc)++async def _miner_corroborate() -> None:"""EN: Sample CPU for pool-port suspects off the event loop; eachcorroborated case becomes a MINING_SUSPECT alert.@@ -1727,6 +1767,9 @@ def _load_settings() -> None:# persisted opt-in is set AND the platform allows it.# FR: Ask-on-first-connect (NFQUEUE Linux) — démarré seulement si# l'opt-in persisté est posé ET la plateforme le permet.+ ask_mode.configure(+ timeout=db.get_setting("ask_timeout", 15),+ failopen=bool(db.get_setting("ask_failopen", False)))if db.get_setting("ask_enabled", False):ok, why = ask_mode.start()if not ok:@@ -1767,6 +1810,7 @@ async def _startup() -> None:_load_settings()_start_capture()asyncio.get_running_loop().create_task(_drain_loop())+ asyncio.get_running_loop().create_task(_gossip_loop())threading.Thread(target=_flush_loop, daemon=True).start()threading.Thread(target=_cleanup_loop, daemon=True).start()@@ -1786,6 +1830,8 @@ async def _shutdown_all() -> None:_shutdown = True_stop_capture()ebpf.stop()+ ebpf_enforcer.stop()+ ask_mode.stop()sink.stop()if _media_monitor:_media_monitor.stop()@@ -1927,6 +1973,10 @@ async def post_settings(body: SettingsBody) -> dict:ask_mode.stop()if key == "gossip_peers":peer_sync.configure(value if isinstance(value, list) else [])+ if key in ("ask_timeout", "ask_failopen"):+ ask_mode.configure(+ timeout=db.get_setting("ask_timeout", 15),+ failopen=bool(db.get_setting("ask_failopen", False)))if key == "integrity_watch":integrity.configure(bool(value))if key == "ebpf_probe":@@ -3054,6 +3104,54 @@ async def hollow_check(body: PidBody) -> dict:return await loop.run_in_executor(None, hollowmod.hollow_check, body.pid)[email protected]("/security/ebpf_enforce", dependencies=_AUTH)+async def ebpf_enforce_status() -> dict:+ """EN: cgroup-skb enforcer status — availability reason is reported+ honestly (needs Linux + root + bcc + cgroup2).+ FR: État de l'enforceur cgroup-skb — la raison d'indisponibilité est+ rapportée honnêtement (Linux + root + bcc + cgroup2)."""+ ok, why = ebpf_enforce.available()+ return {"available": ok, "reason": why, **ebpf_enforcer.status()}++[email protected]("/security/ebpf/isolate", dependencies=_AUTH)+async def ebpf_isolate(body: PidBody) -> dict:+ """EN: Move a process into the snitch cgroup — its egress then flows+ through the kernel drop program (block rules added via+ /security/ebpf/block apply to it specifically, host untouched).+ Lazy-starts the enforcer; failure is honest, never fake success.+ FR: Déplace un processus dans le cgroup snitch — son egress passe+ alors par le programme de drop noyau (les blocages ajoutés via+ /security/ebpf/block s'appliquent à lui seul, l'hôte intact)."""+ if body.pid <= 3 or body.pid == os.getpid():+ raise HTTPException(400, "refusing to isolate a system/critical pid")+ loop = asyncio.get_running_loop()+ if not ebpf_enforcer.status()["attached"]:+ ok, why = await loop.run_in_executor(None, ebpf_enforcer.start)+ if not ok:+ return {"applied": False, "reason": why}+ ok, why = await loop.run_in_executor(+ None, ebpf_enforcer.isolate_pid, body.pid)+ return {"applied": ok, "reason": why}++[email protected]("/security/ebpf/block", dependencies=_AUTH)+async def ebpf_block(body: ThreatCheckBody) -> dict:+ """EN: Add a destination IP to the kernel drop map — drops apply only+ to processes inside the snitch cgroup (see /security/ebpf/isolate).+ FR: Ajoute une IP destination à la map de drop noyau — les drops ne+ s'appliquent qu'aux processus du cgroup snitch (voir+ /security/ebpf/isolate)."""+ loop = asyncio.get_running_loop()+ if not ebpf_enforcer.status()["attached"]:+ ok, why = await loop.run_in_executor(None, ebpf_enforcer.start)+ if not ok:+ return {"applied": False, "reason": why}+ ok, why = await loop.run_in_executor(+ None, ebpf_enforcer.block_ip, body.ip)+ return {"applied": ok, "reason": why}++@app.post("/security/explain", dependencies=_AUTH)async def security_explain_post(body: ExplainBody) -> dict:"""EN: Alert explanation — deterministic bilingual templates always;diff --git a/backend/detection/askmode.py b/backend/detection/askmode.pyindex 639b751..bbcc56d 100644--- a/backend/detection/askmode.py+++ b/backend/detection/askmode.py@@ -91,6 +91,20 @@ class AskMode:# ── lifecycle / cycle de vie ──────────────────────────────────────────+ def configure(self, timeout: Optional[float] = None,+ failopen: Optional[bool] = None) -> None:+ """EN: Live-update timeout / fail-open policy from settings — takes+ effect on the next pending flow (no restart needed).+ FR: Met à jour à chaud timeout / fail-open depuis les réglages —+ effet au prochain flux en attente (pas de redémarrage)."""+ if timeout is not None:+ try:+ self._timeout = max(3.0, min(float(timeout), 120.0))+ except (TypeError, ValueError):+ pass+ if failopen is not None:+ self._failopen = bool(failopen)+def start(self) -> tuple[bool, str]:ok, why = available()if not ok:diff --git a/backend/detection/ebpf_enforce.py b/backend/detection/ebpf_enforce.pyindex d051452..6896c69 100644--- a/backend/detection/ebpf_enforce.py+++ b/backend/detection/ebpf_enforce.py@@ -106,23 +106,31 @@ class EbpfEnforcer:return False, whytry:from bcc import BPF+ except ImportError as e: # pragma: no cover+ return False, str(e)+ # EN: Create OUR cgroup first — the program attaches to it, so the+ # drop map filters ONLY processes moved inside via+ # isolate_pid(). Attaching at the cgroup2 root would make every+ # block host-wide, silently contradicting the per-process+ # promise.+ # FR: Créer NOTRE cgroup d'abord — le programme s'y attache, donc la+ # map de drop ne filtre QUE les processus déplacés dedans via+ # isolate_pid(). Un attach à la racine cgroup2 rendrait chaque+ # blocage global, contredisant la promesse par processus.+ try:+ _CGROUP_DIR.mkdir(exist_ok=True)+ except OSError as e:+ return False, f"cgroup dir unavailable: {e}"+ try:self._b = BPF(text=_PROG)self._fn = self._b.load_func("egress_drop", BPF.CGROUP_SKB)- # EN: Attach at the cgroup2 root — covers every process;- # per-process isolation narrows via our own cgroup below.- # FR: Attach à la racine cgroup2 — couvre tous les processus ;- # l'isolation par processus affine via notre cgroup.- root = str(_cgroup2_root())- self._b.attach_cgroup(self._fn, root,+ target = str(_CGROUP_DIR)+ self._b.attach_cgroup(self._fn, target,self._b.BPFAttachType.CGROUP_INET_EGRESS)- self._attached_to = root+ self._attached_to = targetexcept Exception as e: # noqa: BLE001self._b = Nonereturn False, f"bpf attach failed: {e}"- try:- _CGROUP_DIR.mkdir(exist_ok=True)- except OSError:- passreturn True, ""def stop(self) -> None:diff --git a/backend/detection/iforest.py b/backend/detection/iforest.pyindex 3016b62..3a96b79 100644--- a/backend/detection/iforest.py+++ b/backend/detection/iforest.py@@ -76,9 +76,13 @@ class IsolationForest:self._trees = []if len(data) < 16:return 0- sub = data if len(data) <= self.sample else \- self._rng.sample(data, self.sample)for _ in range(self.n_trees):+ # EN: Fresh subsample per tree (paper-standard) — sharing one+ # subsample correlated every tree and wasted diversity.+ # FR: Sous-échantillon frais par arbre (standard du papier) —+ # partager un seul échantillon corrélait tous les arbres.+ sub = data if len(data) <= self.sample else \+ self._rng.sample(data, self.sample)self._trees.append(self._build(sub, 0))return len(self._trees)@@ -87,11 +91,21 @@ class IsolationForest:if len(pts) <= 1 or depth >= self.max_depth:return nodenfeat = len(pts[0])- feat = self._rng.randrange(nfeat)- col = [p[feat] for p in pts]- lo, hi = min(col), max(col)- if lo == hi:+ # EN: Split only among features with actual variance in this subset.+ # Constant columns (e.g. the direction placeholder, a fixed+ # hour) can never separate points — picking them produced+ # degenerate fat leaves that compressed every score toward 0.5.+ # FR: Ne splitter que sur les features à variance réelle. Les+ # colonnes constantes ne séparent rien — elles produisaient des+ # feuilles grasses qui compressaient tous les scores vers 0,5.+ cols = list(zip(*pts))+ cands = [f for f in range(nfeat)+ if min(cols[f]) != max(cols[f])]+ if not cands:return node # EN: no split possible+ feat = self._rng.choice(cands)+ col = cols[feat]+ lo, hi = min(col), max(col)node.feat = featnode.split = self._rng.uniform(lo, hi)left = [p for p in pts if p[feat] < node.split]diff --git a/backend/tests/test_integration_os.py b/backend/tests/test_integration_os.pyindex 72593ee..8b53bc9 100644--- a/backend/tests/test_integration_os.py+++ b/backend/tests/test_integration_os.py@@ -327,3 +327,76 @@ class TestMacosReal:finally:fm.remove_rule(rule["id"])assert "itest-sinkhole.example" not in fake_hosts.read_text()++[email protected](SYSTEM != "linux", reason="linux only")+class TestLinuxV15Real:+ """EN: v1.5 primitives on a real kernel — nftables, firejail,+ netfilterqueue, bcc/cgroup. All probe availability first and skip+ honestly; they never fake a pass.+ FR: Primitives v1.5 sur un vrai noyau — nftables, firejail,+ netfilterqueue, bcc/cgroup. Sondes d'abord, skip honnête sinon."""++ def test_nftables_table_lifecycle(self):+ """EN: If `nft` exists, a dedicated `inet snitch` table can be+ created and destroyed for real — the path _nft_apply() uses.+ FR: Si `nft` existe, une table `inet snitch` dédiée se crée et se+ détruit réellement — le chemin utilisé par _nft_apply()."""+ import shutil+ if not shutil.which("nft"):+ pytest.skip("nft binary missing")+ probe = _sudo(["nft", "list", "table", "inet", "snitch_itest"])+ _run(probe) # may exist+ _run(_sudo(["nft", "delete", "table", "inet", "snitch_itest"]))+ try:+ res = _run(_sudo(["nft", "add", "table", "inet", "snitch_itest"]))+ assert res.returncode == 0, res.stderr[:200]+ res = _run(_sudo(["nft", "add", "chain", "inet", "snitch_itest",+ "output", "{", "type", "filter", "hook",+ "output", "priority", "0", ";", "}"]))+ assert res.returncode == 0, res.stderr[:200]+ finally:+ _run(_sudo(["nft", "delete", "table", "inet", "snitch_itest"]))+ res = _run(_sudo(["nft", "list", "table", "inet", "snitch_itest"]))+ assert res.returncode != 0 # really gone++ def test_firejail_net_none_denies_egress(self, tmp_path):+ """EN: If firejail exists, `firejail --net=none` must actually+ refuse a TCP connect — same guarantee unshare proves.+ FR: Si firejail existe, `--net=none` doit réellement refuser une+ connexion TCP — même garantie que unshare."""+ import shutil+ if not shutil.which("firejail"):+ pytest.skip("firejail binary missing")+ probe = tmp_path / "probe.py"+ probe.write_text(_probe_source())+ res = _run(["firejail", "--net=none", "--quiet",+ sys.executable, str(probe)], timeout=30)+ assert "NET_DENIED" in res.stdout, (+ f"egress not denied: {res.stdout!r} {res.stderr[:200]!r}")++ def test_netfilterqueue_available_probe(self):+ """EN: askmode.available() must answer honestly on a real Linux+ box — either (True,"") when root+libnetfilter_queue+NetfilterQueue+ are all present, or (False, <reason>) that names what's missing.+ FR: askmode.available() répond honnêtement — True ou une raison+ nommant ce qui manque."""+ from detection import askmode+ ok, why = askmode.available()+ if ok:+ import os as _os+ assert _os.geteuid() == 0+ else:+ assert why and isinstance(why, str)++ def test_ebpf_enforce_available_probe(self):+ """EN: ebpf_enforce.available() reports a concrete reason —+ never crashes, never lies on a real kernel.+ FR: ebpf_enforce.available() rapporte une raison concrète —+ jamais de crash, jamais de mensonge."""+ from detection import ebpf_enforce+ ok, why = ebpf_enforce.available()+ if not ok:+ assert why and isinstance(why, str)+ st = ebpf_enforce.EbpfEnforcer().status()+ assert st["attached"] is False # nothing starteddiff --git a/backend/tests/test_v15_features.py b/backend/tests/test_v15_features.pyindex 255a3dd..3e584cb 100644--- a/backend/tests/test_v15_features.py+++ b/backend/tests/test_v15_features.py@@ -312,19 +312,30 @@ def test_flow_ml_inert_then_scores():from detection.mlflow import FlowAnomaly, _TRAIN_MINm = FlowAnomaly()t = time.time()- # EN: Learn a boring baseline — same proc, same port, regular.- # FR: Une baseline monotone — même processus, même port, régulier.- for i in range(_TRAIN_MIN + 60):- m.observe("firefox", f"93.184.{i % 250}.{(i // 250)}",- 443, "out", 1200, t + i)+ # EN: Learn a realistic baseline — a small stable set of destinations+ # (intervals + fanout stay meaningful), boring web ports/sizes.+ # FR: Baseline réaliste — petit ensemble stable de destinations+ # (intervalles + fanout significatifs), ports/tailles web banals.+ import random as _r+ rng = _r.Random(0)+ ips = [f"93.184.216.{i}" for i in range(20)]+ for i in range(_TRAIN_MIN + 100):+ m.observe("firefox", ips[i % 20],+ 443 if rng.random() < 0.7 else 80, "out",+ 400 + rng.randrange(2400), t + i * 2)# EN: Score still available after training; an insane flow (weird# port, giant packet, odd hour vs learned) should score higher.+ # Seeded forest → deterministic split points, no flaky runs.# FR: Un flux aberrant doit scorer plus haut qu'un flux normal.- m._forest.fit(list(m._window))- m._fitted = True- normal_score = m._forest.score(- [443 / 65535.0, 1200 / 65535.0, 0.5, 0.5, 0.5, 1.0])- weird_score = m._forest.score(+ # Forêt seedée → splits déterministes, pas de run flaky.+ from detection.iforest import IsolationForest+ forest = IsolationForest(seed=7)+ forest.fit(list(m._window))+ # EN: Typical point — 40 s interval (20 IPs round-robin), 20/512 fanout.+ # FR: Point typique — intervalle 40 s (20 IPs round-robin), fanout 20/512.+ normal_score = forest.score(+ [443 / 65535.0, 1200 / 65535.0, 0.45, 20 / 512.0, 0.52, 1.0])+ weird_score = forest.score([31337 / 65535.0, 65535 / 65535.0, 0.0, 1.0, 0.999, 1.0])assert weird_score > normal_score@@ -581,3 +592,53 @@ def test_explain_covers_new_types():assert rec is not None, tassert rec["what_en"] and rec["what_fr"]assert rec["actions_en"] and rec["actions_fr"]+++def test_askmode_configure_clamps():+ """EN: Live configure clamps timeout to [3,120] s and applies failopen+ without restarting. / FR: configure borne le timeout à [3,120] s et+ applique failopen sans redémarrage."""+ from detection.askmode import AskMode+ am = AskMode(lambda ctx: None)+ am.configure(timeout=1, failopen=True)+ assert am._timeout == 3.0 and am._failopen is True+ am.configure(timeout=999, failopen=False)+ assert am._timeout == 120.0 and am._failopen is False+ am.configure(timeout="garbage")+ assert am._timeout == 120.0 # EN: bad input keeps last value+ st = am.status()+ assert st["failopen"] is False and st["timeout_s"] == 120.0+++def test_ebpf_enforce_scoped_attach(monkeypatch):+ """EN: start() must attach to the DEDICATED snitch cgroup, never the+ cgroup2 root — a root attach would make every block host-wide,+ silently contradicting the per-process promise.+ FR: start() doit attacher au cgroup snitch DÉDIÉ, jamais la racine —+ un attach racine rendrait chaque blocage global."""+ import platform+ if platform.system().lower() != "linux":+ pytest.skip("cgroup paths are linux-only")+ from detection import ebpf_enforce as m+ attached = {}++ class FakeBPF:+ class BPFAttachType:+ CGROUP_INET_EGRESS = 0+ CGROUP_SKB = 0+ def __init__(self, text=None):+ pass+ def load_func(self, name, t):+ return object()+ def attach_cgroup(self, fn, path, at):+ attached["path"] = path++ monkeypatch.setitem(__import__("sys").modules, "bcc",+ type("B", (), {"BPF": FakeBPF}))+ monkeypatch.setattr(m, "available", lambda: (True, ""))+ monkeypatch.setattr(m._CGROUP_DIR, "mkdir", lambda **kw: None)+ e = m.EbpfEnforcer()+ ok, why = e.start()+ assert ok, why+ assert attached["path"] == str(m._CGROUP_DIR)+ assert e.status()["attached"] is Truediff --git a/docs/FIREWALL.de.md b/docs/FIREWALL.de.mdindex 126d3c6..3903e82 100644--- a/docs/FIREWALL.de.md+++ b/docs/FIREWALL.de.md@@ -116,3 +116,19 @@ Alle sind **standardmäßig aus oder selbstlimitierend**, degradieren ehrlich un- **Eingebettetes Modell** — `slm_mode=embedded` lädt ein Nutzer-`.gguf` via `llama-cpp-python` — null Netzwerk.- **Native Skelette** — `contrib/wfp-callout/` (WFP-Callout in C + Signierung) und `contrib/macos-filter/` (`NEFilterDataProvider` Swift + Entitlements): Forschungs-Scaffolding, nicht ausgeliefert.- **ASN** — mit `GeoLite2-ASN.mmdb`/`dbip-asn-lite.mmdb` tragen Knoten `asn` neben `org`.++## v1.5 — Passive Inspektion, Kernel-Verdicts & Flotten-Sync++- **Passive TLS-Zertifikatsinspektion** — begrenzte TCP-Reassembly (≤16 KiB/Flow, 30 s TTL) liest die `Certificate`-Nachricht: Issuer/Subject CN+O, Self-Signed, SANs, Validität, `san_mismatch` → `TLS_CERT`. **TLS 1.3 bleibt opak** — ehrlich unbeobachtbar statt geraten.+- **High-Entropy-Wache** — Payloads ≥48 B auf Nicht-TLS-Kanälen mit ≥4,7 Bit/Byte → `HIGH_ENTROPY`; 10-Min-Cooldown pro Host.+- **ICMP-Tunnel-Heuristik** — Echo-Typen mit ≥24 B Payload, ≥3× in 5 Min → `ICMP_TUNNEL`.+- **ML-Flow-Anomalie** — Isolation Forest pur Python (64 Bäume, null Deps) über eigene Flow-Summaries; inert <384 Flows, `ML_ANOMALY` ab 0,62. Baseline-Abweichung, **kein** Malware-Klassifikator.+- **Ask-on-Connect (Linux, opt-in)** — `ask_enabled` + root + `python-netfilterqueue`: neue Ausgangsflüsse werden auf NFQUEUE 7 gehalten bis `POST /security/ask/verdict`; Timeout 15 s, fail-closed (`ask_failopen=1` umgekehrt). Windows/macOS brauchen die signierten Callout-/NetworkExtension-Skelette aus `contrib/`.+- **eBPF-Cgroup-Enforcement (Linux, opt-in)** — `POST /security/ebpf/isolate {pid}` + `/security/ebpf/block {ip}`: Programm an den snitch-Cgroup attachiert — Kernel-Drops gelten NUR für isolierte Prozesse.+- **Hollowing-Check (Linux)** — `POST /security/hollow {pid}` diff't ausführbare file-backed Seiten aus `/proc/<pid>/mem` gegen Disk.+- **IOC-Peer-Sync (opt-in)** — `gossip_peers` ≤32 + `gossip_enabled`: Merkle-Proof-Pakete alle 5 Min per authentifiziertem HTTP(S) — kein Discovery, kein ZK-Protokoll.+- **Syslog (opt-in)** — `syslog_addr` (`host:port` UDP oder `tcp://`) → RFC 3164 `local4`.+- **Firejail-Containment** — `firejail --net=none` bevorzugt, `unshare` als Fallback.+- **nftables-Backend** — eigene `inet snitch`-Tabelle statt iptables, wo `nft` existiert.+- **Actionable Alerts** — strukturierte `actions` (Block IP, Kill/Suspend, Ask-Verdict) als Ein-Klick-Buttons.+- **`asn`/`country` in Custom Rules** — lokale Geo-DB, kombinierbar mit `action=block` als Geo-Fence.diff --git a/docs/FIREWALL.es.md b/docs/FIREWALL.es.mdindex 71339f8..3f65116 100644--- a/docs/FIREWALL.es.md+++ b/docs/FIREWALL.es.md@@ -117,3 +117,19 @@ Todas están **desactivadas por defecto o se autolimitan**, degradan honestament- **Modelo embebido** — `slm_mode=embedded` carga un `.gguf` del usuario vía `llama-cpp-python` — cero red.- **Esqueletos nativos** — `contrib/wfp-callout/` (callout WFP en C + firma) y `contrib/macos-filter/` (`NEFilterDataProvider` Swift + entitlements): scaffolding de investigación, no se distribuyen.- **ASN** — con `GeoLite2-ASN.mmdb`/`dbip-asn-lite.mmdb`, los nodos llevan `asn` además de `org`.++## v1.5 — Inspección pasiva, veredictos en kernel y sincronización de flota++- **Inspección pasiva del certificado TLS** — reensamblado TCP limitado (≤16 KiB/flujo, TTL 30 s) lee el mensaje `Certificate`: CN+O emisor/sujeto, autofirmado, SANs, validez, `san_mismatch` → `TLS_CERT`. **TLS 1.3 queda opaco** — honestamente inobservable en vez de adivinar.+- **Guardia de alta entropía** — payloads ≥48 B en canales no TLS con ≥4,7 bits/byte → `HIGH_ENTROPY`; cooldown 10 min por host.+- **Heurística de túnel ICMP** — tipos echo con ≥24 B de payload, ≥3× en 5 min → `ICMP_TUNNEL`.+- **Anomalía ML de flujo** — isolation forest en Python puro (64 árboles, cero deps) sobre tus propios resúmenes; inerte <384 flujos, `ML_ANOMALY` a 0,62. Desviación de baseline, **no** un clasificador.+- **Ask-on-connect (Linux, opt-in)** — `ask_enabled` + root + `python-netfilterqueue`: nuevos flujos salientes retenidos en NFQUEUE 7 hasta `POST /security/ask/verdict`; timeout 15 s, fail-closed (`ask_failopen=1` invierte). Windows/macOS necesitan los esqueletos firmados de `contrib/`.+- **Enforcement eBPF cgroup (Linux, opt-in)** — `POST /security/ebpf/isolate {pid}` + `/security/ebpf/block {ip}`: programa attach al cgroup snitch — drops en kernel SOLO para procesos aislados.+- **Check de hollowing (Linux)** — `POST /security/hollow {pid}` compara páginas ejecutables file-backed de `/proc/<pid>/mem` con el disco.+- **Sincronización IOC entre pares (opt-in)** — `gossip_peers` ≤32 + `gossip_enabled`: paquetes Merkle cada 5 min por HTTP(S) autenticado — sin discovery, no es ZK.+- **Syslog (opt-in)** — `syslog_addr` (`host:puerto` UDP o `tcp://`) → RFC 3164 `local4`.+- **Contención Firejail** — `firejail --net=none` preferido, `unshare` como fallback.+- **Backend nftables** — tabla `inet snitch` dedicada en lugar de iptables donde existe `nft`.+- **Alertas accionables** — `actions` estructuradas (bloquear IP, matar/suspender, veredicto ask) como botones de un clic.+- **`asn`/`country` en reglas custom** — base geo local, combinable con `action=block` como geo-fence.diff --git a/docs/FIREWALL.ja.md b/docs/FIREWALL.ja.mdindex f276d48..b22a148 100644--- a/docs/FIREWALL.ja.md+++ b/docs/FIREWALL.ja.md@@ -114,3 +114,19 @@ OS ネイティブファイアウォールへ best-effort で適用されます:- **埋め込みモデル** — `slm_mode=embedded` がユーザーの `.gguf` を `llama-cpp-python` で読込 — ネットワーク一切なし。- **ネイティブスケルトン** — `contrib/wfp-callout/`(C の WFP callout+署名メモ)と `contrib/macos-filter/`(`NEFilterDataProvider` Swift+entitlement メモ):研究用スキャフォールド、出荷なし。- **ASN** — `GeoLite2-ASN.mmdb`/`dbip-asn-lite.mmdb` がある場合、ノードに `org` に加え `asn` を付与。++## v1.5 — パッシブ検査、カーネル判定、フリート同期++- **パッシブTLS証明書インスペクション** — 制限付きTCP再構成(≤16 KiB/フロー、TTL 30秒)で `Certificate` メッセージを読み取り:発行者/サブジェクト CN+O、自己署名、SAN、有効期限、`san_mismatch` → `TLS_CERT`。**TLS 1.3は不透明のまま** — 推測せず観測不可と正直に報告。+- **高エントロピー監視** — 非TLSチャネルで ≥48 B・≥4.7ビット/バイトのペイロード → `HIGH_ENTROPY`;ホスト毎10分クールダウン。+- **ICMPトンネル検知** — ≥24 Bペイロードのエコーが5分で3回以上 → `ICMP_TUNNEL`。+- **MLフロー異常** — 純Pythonのisolation forest(64本、依存ゼロ)が自フロー要約をスコアリング;384フロー未満では不活性、0.62で `ML_ANOMALY`。ベースライン偏差でありマルウェア分類器では**ありません**。+- **Ask-on-Connect(Linux、オプトイン)** — `ask_enabled` + root + `python-netfilterqueue`:新規送信フローをNFQUEUE 7に `POST /security/ask/verdict` まで保留;タイムアウト15秒、fail-closed(`ask_failopen=1`で反転)。Windows/macOSは `contrib/` の署名済みcallout/NetworkExtensionが必要。+- **eBPF cgroupエンフォースメント(Linux、オプトイン)** — `POST /security/ebpf/isolate {pid}` + `/security/ebpf/block {ip}`:snitch cgroupへattach — カーネルdropは隔離プロセスのみ。+- **ハロウィングチェック(Linux)** — `POST /security/hollow {pid}` が `/proc/<pid>/mem` のfile-backed実行可能ページをディスクと比較。+- **IOCピア同期(オプトイン)** — `gossip_peers` ≤32 + `gossip_enabled`:Merkleプルーフパックを5分毎に認証HTTP(S)で — 探索なし、ZKプロトコルではありません。+- **Syslog(オプトイン)** — `syslog_addr`(`host:port` UDPまたは `tcp://`)→ RFC 3164 `local4`。+- **Firejailコンテインメント** — `firejail --net=none` 優先、`unshare` にフォールバック。+- **nftablesバックエンド** — `nft` があれば専用 `inet snitch` テーブル(iptablesの代わり)。+- **アクション可能アラート** — 構造化 `actions`(IPブロック、終了/一時停止、ask判定)をワンクリックボタンとして表示。+- **カスタムルールの `asn`/`country`** — ローカルgeo DB、`action=block` と組み合わせてgeoフェンスに。diff --git a/docs/FIREWALL.pt-BR.md b/docs/FIREWALL.pt-BR.mdindex 0ea7a7c..7948e7a 100644--- a/docs/FIREWALL.pt-BR.md+++ b/docs/FIREWALL.pt-BR.md@@ -118,3 +118,19 @@ Todas estão **desativadas por padrão ou autolimitadas**, degradam honestamente- **Modelo embutido** — `slm_mode=embedded` carrega um `.gguf` do usuário via `llama-cpp-python` — zero rede.- **Esqueletos nativos** — `contrib/wfp-callout/` (callout WFP em C + assinatura) e `contrib/macos-filter/` (`NEFilterDataProvider` Swift + entitlements): scaffolding de pesquisa, não distribuídos.- **ASN** — com `GeoLite2-ASN.mmdb`/`dbip-asn-lite.mmdb`, os nós carregam `asn` além de `org`.++## v1.5 — Inspeção passiva, vereditos em kernel e sincronização de frota++- **Inspeção passiva do certificado TLS** — remontagem TCP limitada (≤16 KiB/fluxo, TTL 30 s) lê a mensagem `Certificate`: CN+O emissor/sujeito, autoassinado, SANs, validade, `san_mismatch` → `TLS_CERT`. **TLS 1.3 permanece opaco** — honestamente inobservável em vez de adivinhado.+- **Guarda de alta entropia** — payloads ≥48 B em canais não TLS com ≥4,7 bits/byte → `HIGH_ENTROPY`; cooldown de 10 min por host.+- **Heurística de túnel ICMP** — tipos echo com ≥24 B de payload, ≥3× em 5 min → `ICMP_TUNNEL`.+- **Anomalia ML de fluxo** — isolation forest em Python puro (64 árvores, zero deps) sobre seus próprios resumos; inerte <384 fluxos, `ML_ANOMALY` a 0,62. Desvio de baseline, **não** um classificador.+- **Ask-on-connect (Linux, opt-in)** — `ask_enabled` + root + `python-netfilterqueue`: novos fluxos de saída retidos na NFQUEUE 7 até `POST /security/ask/verdict`; timeout 15 s, fail-closed (`ask_failopen=1` inverte). Windows/macOS precisam dos esqueletos assinados em `contrib/`.+- **Enforcement eBPF cgroup (Linux, opt-in)** — `POST /security/ebpf/isolate {pid}` + `/security/ebpf/block {ip}`: programa attach ao cgroup snitch — drops em kernel SÓ para processos isolados.+- **Check de hollowing (Linux)** — `POST /security/hollow {pid}` compara páginas executáveis file-backed de `/proc/<pid>/mem` com o disco.+- **Sincronização IOC entre pares (opt-in)** — `gossip_peers` ≤32 + `gossip_enabled`: pacotes Merkle a cada 5 min via HTTP(S) autenticado — sem discovery, não é ZK.+- **Syslog (opt-in)** — `syslog_addr` (`host:porta` UDP ou `tcp://`) → RFC 3164 `local4`.+- **Contenção Firejail** — `firejail --net=none` preferido, `unshare` como fallback.+- **Backend nftables** — tabela `inet snitch` dedicada em vez de iptables onde existe `nft`.+- **Alertas acionáveis** — `actions` estruturadas (bloquear IP, matar/suspender, veredito ask) como botões de um clique.+- **`asn`/`country` em regras custom** — base geo local, combinável com `action=block` como geo-fence.diff --git a/docs/FIREWALL.ru.md b/docs/FIREWALL.ru.mdindex aa74328..79ac94d 100644--- a/docs/FIREWALL.ru.md+++ b/docs/FIREWALL.ru.md@@ -115,3 +115,19 @@ endpoint'ы получают `{alert, source, text}`. Сбои пишутся в- **Встроенная модель** — `slm_mode=embedded` загружает `.gguf` пользователя через `llama-cpp-python` — ноль сети.- **Нативные скелеты** — `contrib/wfp-callout/` (WFP callout на C + подпись) и `contrib/macos-filter/` (`NEFilterDataProvider` Swift + entitlements): исследовательский каркас, не поставляется.- **ASN** — с `GeoLite2-ASN.mmdb`/`dbip-asn-lite.mmdb` узлы несут `asn` в дополнение к `org`.++## v1.5 — Пассивная инспекция, вердикты ядра и синхронизация флота++- **Пассивная инспекция TLS-сертификата** — ограниченная TCP-сборка (≤16 КиБ/поток, TTL 30 с) читает сообщение `Certificate`: CN+O издателя/субъекта, самоподпись, SAN, срок, `san_mismatch` → `TLS_CERT`. **TLS 1.3 остаётся непрозрачным** — честно ненаблюдаем, а не угадываем.+- **Сторож высокой энтропии** — payloads ≥48 Б на не-TLS каналах с ≥4,7 бит/байт → `HIGH_ENTROPY`; кулдаун 10 мин на хост.+- **Эвристика ICMP-туннеля** — echo с ≥24 Б payload, ≥3× за 5 мин → `ICMP_TUNNEL`.+- **ML-аномалия потока** — isolation forest на чистом Python (64 дерева, ноль зависимостей) по вашим же сводкам; неактивно <384 потоков, `ML_ANOMALY` при 0,62. Отклонение от baseline, **не** классификатор.+- **Ask-on-connect (Linux, opt-in)** — `ask_enabled` + root + `python-netfilterqueue`: новые исходящие потоки удерживаются в NFQUEUE 7 до `POST /security/ask/verdict`; таймаут 15 с, fail-closed (`ask_failopen=1` наоборот). Windows/macOS требуют подписанные callout/NetworkExtension из `contrib/`.+- **eBPF cgroup-эндфорсмент (Linux, opt-in)** — `POST /security/ebpf/isolate {pid}` + `/security/ebpf/block {ip}`: программа attach к cgroup snitch — дропы в ядре ТОЛЬКО для изолированных процессов.+- **Проверка hollowing (Linux)** — `POST /security/hollow {pid}` сравнивает file-backed исполняемые страницы `/proc/<pid>/mem` с диском.+- **Синхронизация IOC с пирами (opt-in)** — `gossip_peers` ≤32 + `gossip_enabled`: Merkle-пакеты каждые 5 мин по аутентифицированному HTTP(S) — без discovery, не ZK.+- **Syslog (opt-in)** — `syslog_addr` (`хост:порт` UDP или `tcp://`) → RFC 3164 `local4`.+- **Сдерживание Firejail** — `firejail --net=none` предпочтительно, `unshare` как фолбэк.+- **Backend nftables** — отдельная таблица `inet snitch` вместо iptables, где есть `nft`.+- **Действующие алерты** — структурные `actions` (блок IP, убить/приостановить, вердикт ask) кнопками в один клик.+- **`asn`/`country` в своих правилах** — локальная geo-БД, комбинируется с `action=block` как geo-fence.diff --git a/docs/FIREWALL.zh-CN.md b/docs/FIREWALL.zh-CN.mdindex 3c355a5..6b7467c 100644--- a/docs/FIREWALL.zh-CN.md+++ b/docs/FIREWALL.zh-CN.md@@ -107,3 +107,19 @@ Snitch **不**在用户态过滤数据包。规则会被尽力下发到操作系- **内置模型** — `slm_mode=embedded` 通过 `llama-cpp-python` 加载用户 `.gguf` — 完全零网络。- **原生骨架** — `contrib/wfp-callout/`(C 版 WFP callout+签名说明)与 `contrib/macos-filter/`(Swift `NEFilterDataProvider`+entitlement 说明):研究用脚手架,不随产品分发。- **ASN** — 存在 `GeoLite2-ASN.mmdb`/`dbip-asn-lite.mmdb` 时,节点除 `org` 外还带 `asn`。++## v1.5 — 被动检查、内核判定与集群同步++- **被动 TLS 证书检查** — 有界 TCP 重组(≤16 KiB/流,TTL 30 秒)读取 `Certificate` 消息:签发者/主体 CN+O、自签名、SAN、有效期、`san_mismatch` → `TLS_CERT`。**TLS 1.3 保持不透明** — 诚实报告不可观测而非猜测。+- **高熵监视** — 非 TLS 通道上 ≥48 B、≥4.7 比特/字节的载荷 → `HIGH_ENTROPY`;每主机 10 分钟冷却。+- **ICMP 隧道启发式** — 载荷 ≥24 B 的 echo 类型,5 分钟内 ≥3 次 → `ICMP_TUNNEL`。+- **ML 流异常** — 纯 Python isolation forest(64 棵树、零依赖)对您自己的流摘要打分;<384 流时惰性,0.62 触发 `ML_ANOMALY`。基线偏差,**不是**恶意软件分类器。+- **Ask-on-connect(Linux,可选)** — `ask_enabled` + root + `python-netfilterqueue`:新出站流在 NFQUEUE 7 挂起至 `POST /security/ask/verdict`;超时 15 秒,默认拒绝(`ask_failopen=1` 反转)。Windows/macOS 需要 `contrib/` 中的签名 callout/NetworkExtension。+- **eBPF cgroup 执行(Linux,可选)** — `POST /security/ebpf/isolate {pid}` + `/security/ebpf/block {ip}`:程序挂载到 snitch cgroup — 内核丢弃仅作用于被隔离进程。+- **空心化检查(Linux)** — `POST /security/hollow {pid}` 对比 `/proc/<pid>/mem` 中文件映射的可执行页与磁盘。+- **IOC 节点同步(可选)** — `gossip_peers` ≤32 + `gossip_enabled`:每 5 分钟经认证 HTTP(S) 推送 Merkle 证明包 — 无发现机制,非 ZK。+- **Syslog(可选)** — `syslog_addr`(`主机:端口` UDP 或 `tcp://`)→ RFC 3164 `local4`。+- **Firejail 隔离** — 优先 `firejail --net=none`,回退 `unshare`。+- **nftables 后端** — 有 `nft` 时使用专用 `inet snitch` 表替代 iptables。+- **可操作告警** — 结构化 `actions`(封锁 IP、终止/挂起、ask 判定)以一键按钮呈现。+- **自定义规则的 `asn`/`country`** — 本地 geo 数据库,可与 `action=block` 组成地理围栏。diff --git a/frontend/src/components/Settings.jsx b/frontend/src/components/Settings.jsxindex fcf6515..c1ef7d1 100644--- a/frontend/src/components/Settings.jsx+++ b/frontend/src/components/Settings.jsx@@ -47,17 +47,20 @@ export function SettingsPanel({ onClose, lang, setLang, watchlist = [], onWatchlconst [pairing, setPairing] = useState(null)const [sbPath, setSbPath] = useState('')const [sbResult, setSbResult] = useState(null)+ const [askStatus, setAskStatus] = useState(null)useEffect(() => {;(async () => {const base = await apiBase()const headers = await authHeaders()try {- const [s, g, i, p] = await Promise.all([+ const [s, g, i, p, a] = await Promise.all([fetch(`${base}/settings`, { headers }).then(r => r.json()),fetch(`${base}/geo/status`, { headers }).then(r => r.json()),fetch(`${base}/capture/interfaces`, { headers }).then(r => r.json()),fetch(`${base}/remote/pairing`, { headers }).then(r => r.json()),+ fetch(`${base}/security/ask`, { headers }).then(r => r.json())+ .catch(() => null),])setSettings(s.settings || {})setRetention(s.settings?.retention_hours ?? 24)@@ -65,6 +68,7 @@ export function SettingsPanel({ onClose, lang, setLang, watchlist = [], onWatchlsetGeoStatus(g)setIfaces(i.interfaces || [])setPairing(p)+ setAskStatus(a)} catch { setSettings({}) }if (window.snitch?.getAutoLaunch) {setAutoLaunch(await window.snitch.getAutoLaunch())@@ -449,6 +453,143 @@ export function SettingsPanel({ onClose, lang, setLang, watchlist = [], onWatchl<div style={{ ...hint, marginTop: 4 }}>{t('wh_privacy')}</div></div>+ {/* Syslog output / Sortie syslog */}+ <div style={{ ...row, display: 'block' }}>+ <div style={label}>{t('sl_title')}</div>+ <div style={hint}>{t('sl_hint')}</div>+ <form onSubmit={e => {+ e.preventDefault()+ save('syslog_addr', e.target.elements.sladdr.value.trim())+ }} style={{ display: 'flex', gap: 6, marginTop: 8 }}>+ <input+ name="sladdr"+ defaultValue={settings?.syslog_addr ?? ''}+ placeholder={t('sl_ph')}+ aria-label={t('sl_title')}+ style={{ flex: 1, background: 'var(--bg)', border: '1px solid var(--border)', borderRadius: 6, color: 'var(--text)', padding: '6px 10px', fontSize: 11, outline: 'none' }}+ />+ <button type="submit" style={{+ background: 'var(--bg)', border: '1px solid var(--border)',+ borderRadius: 6, color: 'var(--text-dim)', padding: '6px 12px',+ fontSize: 10, cursor: 'pointer',+ }}>{t('save')}</button>+ </form>+ </div>++ {/* Ask-on-connect (NFQUEUE) / Ask-on-connect (NFQUEUE) */}+ <div style={{ ...row, display: 'block' }}>+ <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>+ <div>+ <div style={label}>{t('ask_title')}</div>+ <div style={hint}>{t('ask_hint')}</div>+ </div>+ <button+ onClick={() => {+ const v = !settings?.ask_enabled+ setSettings(s => ({ ...s, ask_enabled: v }))+ save('ask_enabled', v)+ }}+ role="switch" aria-checked={!!settings?.ask_enabled}+ style={{+ width: 36, height: 20, borderRadius: 10, border: 'none',+ background: settings?.ask_enabled ? '#3b82f6' : 'var(--bg)',+ outline: '1px solid var(--border)', cursor: 'pointer',+ position: 'relative', flexShrink: 0,+ }}>+ <div style={{+ width: 14, height: 14, borderRadius: '50%', background: 'var(--text)',+ position: 'absolute', top: 3, left: settings?.ask_enabled ? 19 : 3,+ transition: 'left 0.15s',+ }} />+ </button>+ </div>+ {settings?.ask_enabled && (+ <div style={{ display: 'flex', gap: 8, marginTop: 8, alignItems: 'center' }}>+ <select+ value={settings?.ask_timeout ?? 15}+ onChange={e => {+ const v = +e.target.value+ setSettings(s => ({ ...s, ask_timeout: v }))+ save('ask_timeout', v)+ }}+ aria-label={t('ask_timeout')}+ style={{ background: 'var(--bg)', border: '1px solid var(--border)', borderRadius: 6, color: 'var(--text)', padding: '4px 8px', fontSize: 11 }}+ >+ {[10, 15, 30, 60].map(v => (+ <option key={v} value={v}>{t('ask_timeout')}: {v}s</option>+ ))}+ </select>+ <label style={{ ...hint, display: 'flex', gap: 5, alignItems: 'center', cursor: 'pointer' }}>+ <input+ type="checkbox"+ checked={!!settings?.ask_failopen}+ onChange={e => {+ setSettings(s => ({ ...s, ask_failopen: e.target.checked }))+ save('ask_failopen', e.target.checked)+ }}+ />+ {t('ask_failopen')}+ </label>+ </div>+ )}+ {askStatus && !askStatus.available && (+ <div style={{ ...hint, marginTop: 4 }}>{t('ask_unavailable')}: {askStatus.reason}</div>+ )}+ {askStatus?.available && askStatus?.running === false && settings?.ask_enabled && (+ <div style={{ ...hint, marginTop: 4 }}>{t('ask_not_running')}</div>+ )}+ </div>++ {/* IOC peer sync / Sync IOC entre pairs */}+ <div style={{ ...row, display: 'block' }}>+ <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>+ <div>+ <div style={label}>{t('gs_title')}</div>+ <div style={hint}>{t('gs_hint')}</div>+ </div>+ <button+ onClick={() => {+ const v = !settings?.gossip_enabled+ setSettings(s => ({ ...s, gossip_enabled: v }))+ save('gossip_enabled', v)+ }}+ role="switch" aria-checked={!!settings?.gossip_enabled}+ style={{+ width: 36, height: 20, borderRadius: 10, border: 'none',+ background: settings?.gossip_enabled ? '#3b82f6' : 'var(--bg)',+ outline: '1px solid var(--border)', cursor: 'pointer',+ position: 'relative', flexShrink: 0,+ }}>+ <div style={{+ width: 14, height: 14, borderRadius: '50%', background: 'var(--text)',+ position: 'absolute', top: 3, left: settings?.gossip_enabled ? 19 : 3,+ transition: 'left 0.15s',+ }} />+ </button>+ </div>+ <form onSubmit={e => {+ e.preventDefault()+ const peers = e.target.elements.gpeers.value+ .split(/[\s,]+/).map(s => s.trim()).filter(Boolean).slice(0, 32)+ setSettings(s => ({ ...s, gossip_peers: peers }))+ save('gossip_peers', peers)+ }} style={{ display: 'flex', gap: 6, marginTop: 8 }}>+ <input+ name="gpeers"+ defaultValue={(settings?.gossip_peers || []).join(', ')}+ placeholder={t('gs_peers_ph')}+ aria-label={t('gs_title')}+ style={{ flex: 1, background: 'var(--bg)', border: '1px solid var(--border)', borderRadius: 6, color: 'var(--text)', padding: '6px 10px', fontSize: 11, outline: 'none' }}+ />+ <button type="submit" style={{+ background: 'var(--bg)', border: '1px solid var(--border)',+ borderRadius: 6, color: 'var(--text-dim)', padding: '6px 12px',+ fontSize: 10, cursor: 'pointer',+ }}>{t('save')}</button>+ </form>+ <div style={{ ...hint, marginTop: 4 }}>{t('gs_privacy')}</div>+ </div>+{/* Integrity watch / Veille d'intégrité */}<div style={{ ...row, display: 'block' }}><div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>diff --git a/frontend/src/locales/de.js b/frontend/src/locales/de.jsindex 229d69f..d0cfae2 100644--- a/frontend/src/locales/de.js+++ b/frontend/src/locales/de.js@@ -436,4 +436,18 @@ export default {ar_action: 'Aktion',ar_action_alert: 'Nur Alarm',ar_action_block: 'Alarm + Block',++ sl_title: 'Syslog-Ausgabe',+ sl_hint: 'Warn-/Kritisch-Alarme an einen Syslog-Kollektor weiterleiten (RFC 3164, UDP oder tcp://). Opt-in — nichts wird gesendet, bis eine Adresse gesetzt ist.',+ sl_ph: 'host:port oder tcp://host:port',+ ask_title: 'Ask-on-Connect',+ ask_hint: 'Neue ausgehende Flüsse zurückhalten, bis Sie erlauben/verweigern — wie Little Snitch. Linux + NFQUEUE + Root nötig.',+ ask_timeout: 'Timeout',+ ask_failopen: 'Fail-open (bei Timeout erlauben — unsicherer)',+ ask_unavailable: 'Ask-Modus auf diesem System nicht verfügbar',+ ask_not_running: 'Ask-Modus aktiviert, läuft aber nicht — Backend-Logs prüfen',+ gs_title: 'IOC-Peer-Sync',+ gs_hint: 'Gesalzene Merkle-Proof-Pakete alle 5 Min an explizit gepaarte Snitch-Instanzen pushen — nur Hash-Commitments, nie rohe Indikatoren.',+ gs_peers_ph: 'host:port, kommagetrennt',+ gs_privacy: 'Opt-in Flotten-Sharing — Pakete gehen nur an die hier gelisteten Peers.',}diff --git a/frontend/src/locales/en.js b/frontend/src/locales/en.jsindex 274f152..8e96520 100644--- a/frontend/src/locales/en.js+++ b/frontend/src/locales/en.js@@ -440,4 +440,18 @@ export default { // Navigationar_action: 'Action',ar_action_alert: 'Alert only',ar_action_block: 'Alert + block',++ sl_title: 'Syslog output',+ sl_hint: 'Forward warning/critical alerts to a syslog collector (RFC 3164, UDP or tcp://). Opt-in — nothing is sent until an address is set.',+ sl_ph: 'host:port or tcp://host:port',+ ask_title: 'Ask-on-connect',+ ask_hint: 'Hold new outbound flows until you allow/deny — the Little Snitch-style prompt. Linux + NFQUEUE + root required.',+ ask_timeout: 'Timeout',+ ask_failopen: 'Fail-open (allow on timeout — less safe)',+ ask_unavailable: 'Ask mode unavailable on this system',+ ask_not_running: 'Ask mode is enabled but not running — check backend logs',+ gs_title: 'IOC peer sync',+ gs_hint: 'Push salted-Merkle proof packs to explicitly paired Snitch instances every 5 min — hash commitments only, never raw indicators.',+ gs_peers_ph: 'host:port, comma-separated',+ gs_privacy: 'Opt-in fleet sharing — packs leave only for the peers you list here.',}diff --git a/frontend/src/locales/es.js b/frontend/src/locales/es.jsindex 886e2c6..c8c6b15 100644--- a/frontend/src/locales/es.js+++ b/frontend/src/locales/es.js@@ -434,4 +434,18 @@ export default { // Navegaciónar_action: 'Acción',ar_action_alert: 'Solo alerta',ar_action_block: 'Alerta + bloqueo',++ sl_title: 'Salida syslog',+ sl_hint: 'Reenvía alertas warning/críticas a un colector syslog (RFC 3164, UDP o tcp://). Opt-in — nada se envía hasta definir una dirección.',+ sl_ph: 'host:puerto o tcp://host:puerto',+ ask_title: 'Ask-on-connect',+ ask_hint: 'Retener nuevos flujos salientes hasta que permitas/niegues — la ventana estilo Little Snitch. Requiere Linux + NFQUEUE + root.',+ ask_timeout: 'Tiempo límite',+ ask_failopen: 'Fail-open (permitir al expirar — menos seguro)',+ ask_unavailable: 'Modo ask no disponible en este sistema',+ ask_not_running: 'Modo ask activado pero no iniciado — revisa los logs del backend',+ gs_title: 'Sincronización IOC entre pares',+ gs_hint: 'Enviar paquetes Merkle salados a instancias Snitch emparejadas explícitamente cada 5 min — solo compromisos hash, nunca indicadores crudos.',+ gs_peers_ph: 'host:puerto, separados por comas',+ gs_privacy: 'Compartición opt-in — los paquetes solo salen hacia los pares listados aquí.',}diff --git a/frontend/src/locales/fr.js b/frontend/src/locales/fr.jsindex 7d994cf..a90ffce 100644--- a/frontend/src/locales/fr.js+++ b/frontend/src/locales/fr.js@@ -436,4 +436,18 @@ export default { // Navigationar_action: 'Action',ar_action_alert: 'Alerte seule',ar_action_block: 'Alerte + blocage',++ sl_title: 'Sortie syslog',+ sl_hint: "Relayer les alertes warning/critiques vers un collecteur syslog (RFC 3164, UDP ou tcp://). Opt-in — rien n'est envoyé tant qu'aucune adresse n'est définie.",+ sl_ph: 'hôte:port ou tcp://hôte:port',+ ask_title: 'Ask-on-connect',+ ask_hint: "Retenir les nouveaux flux sortants jusqu'à votre allow/deny — la pop-up façon Little Snitch. Linux + NFQUEUE + root requis.",+ ask_timeout: 'Timeout',+ ask_failopen: 'Fail-open (autoriser au timeout — moins sûr)',+ ask_unavailable: 'Mode ask indisponible sur ce système',+ ask_not_running: 'Mode ask activé mais non démarré — voir les logs backend',+ gs_title: 'Sync IOC entre pairs',+ gs_hint: "Pousser les paquets Merkle salés vers des instances Snitch explicitement appairées toutes les 5 min — engagements de hash seulement, jamais d'indicateurs bruts.",+ gs_peers_ph: 'hôte:port, séparés par des virgules',+ gs_privacy: 'Partage de flotte opt-in — les paquets ne partent que vers les pairs listés ici.',}diff --git a/frontend/src/locales/ja.js b/frontend/src/locales/ja.jsindex e874eff..b4b81a6 100644--- a/frontend/src/locales/ja.js+++ b/frontend/src/locales/ja.js@@ -436,4 +436,18 @@ export default {ar_action: 'アクション',ar_action_alert: 'アラートのみ',ar_action_block: 'アラート+ブロック',++ sl_title: 'Syslog出力',+ sl_hint: '警告/重大アラートをsyslogコレクターへ転送(RFC 3164、UDPまたはtcp://)。オプトイン — アドレス未設定では送信しません。',+ sl_ph: 'host:port または tcp://host:port',+ ask_title: 'Ask-on-Connect',+ ask_hint: '新規送信フローを許可/拒否まで保留 — Little Snitch式プロンプト。Linux + NFQUEUE + root が必要。',+ ask_timeout: 'タイムアウト',+ ask_failopen: 'フェイルオープン(タイムアウト時に許可 — 安全性低下)',+ ask_unavailable: 'このシステムではAskモードは利用できません',+ ask_not_running: 'Askモードは有効ですが動作していません — バックエンドログを確認',+ gs_title: 'IOCピア同期',+ gs_hint: '塩付きMerkleプルーフパックを明示的にペアリングしたSnitchインスタンスへ5分毎にプッシュ — ハッシュコミットメントのみ、生インジケーターは送信しません。',+ gs_peers_ph: 'host:port(カンマ区切り)',+ gs_privacy: 'オプトインのフリート共有 — パックはここに列挙したピアにのみ送信されます。',}diff --git a/frontend/src/locales/pt-BR.js b/frontend/src/locales/pt-BR.jsindex c57a980..0b345e4 100644--- a/frontend/src/locales/pt-BR.js+++ b/frontend/src/locales/pt-BR.js@@ -436,4 +436,18 @@ export default {ar_action: 'Ação',ar_action_alert: 'Só alerta',ar_action_block: 'Alerta + bloqueio',++ sl_title: 'Saída syslog',+ sl_hint: 'Encaminha alertas warning/críticos a um coletor syslog (RFC 3164, UDP ou tcp://). Opt-in — nada é enviado até definir um endereço.',+ sl_ph: 'host:porta ou tcp://host:porta',+ ask_title: 'Ask-on-connect',+ ask_hint: 'Retém novos fluxos de saída até você permitir/negar — o prompt estilo Little Snitch. Requer Linux + NFQUEUE + root.',+ ask_timeout: 'Timeout',+ ask_failopen: 'Fail-open (permitir no timeout — menos seguro)',+ ask_unavailable: 'Modo ask indisponível neste sistema',+ ask_not_running: 'Modo ask ativado mas não iniciado — verifique os logs do backend',+ gs_title: 'Sincronização IOC entre pares',+ gs_hint: 'Envia pacotes Merkle com sal a instâncias Snitch pareadas explicitamente a cada 5 min — só compromissos hash, nunca indicadores brutos.',+ gs_peers_ph: 'host:porta, separados por vírgula',+ gs_privacy: 'Compartilhamento opt-in — os pacotes só saem para os pares listados aqui.',}diff --git a/frontend/src/locales/ru.js b/frontend/src/locales/ru.jsindex 54b69ea..a071ec7 100644--- a/frontend/src/locales/ru.js+++ b/frontend/src/locales/ru.js@@ -436,4 +436,18 @@ export default {ar_action: 'Действие',ar_action_alert: 'Только алерт',ar_action_block: 'Алерт + блок',++ sl_title: 'Вывод syslog',+ sl_hint: 'Пересылать алерты warning/critical сборщику syslog (RFC 3164, UDP или tcp://). Opt-in — ничего не отправляется, пока адрес не задан.',+ sl_ph: 'хост:порт или tcp://хост:порт',+ ask_title: 'Ask-on-connect',+ ask_hint: 'Удерживает новые исходящие потоки до вашего разрешить/запретить — как Little Snitch. Нужны Linux + NFQUEUE + root.',+ ask_timeout: 'Таймаут',+ ask_failopen: 'Fail-open (разрешать по таймауту — менее безопасно)',+ ask_unavailable: 'Режим ask недоступен на этой системе',+ ask_not_running: 'Режим ask включён, но не запущен — см. логи бэкенда',+ gs_title: 'Синхронизация IOC с пирами',+ gs_hint: 'Отправлять солёные Merkle-пакеты доказательств явно спаренным экземплярам Snitch каждые 5 мин — только хеш-коммитменты, никогда сырые индикаторы.',+ gs_peers_ph: 'хост:порт, через запятую',+ gs_privacy: 'Opt-in обмен внутри флота — пакеты уходят только перечисленным здесь пирам.',}diff --git a/frontend/src/locales/zh-CN.js b/frontend/src/locales/zh-CN.jsindex 3ff13be..2793fb5 100644--- a/frontend/src/locales/zh-CN.js+++ b/frontend/src/locales/zh-CN.js@@ -436,4 +436,18 @@ export default {ar_action: '动作',ar_action_alert: '仅告警',ar_action_block: '告警+封锁',++ sl_title: 'Syslog 输出',+ sl_hint: '将警告/严重告警转发到 syslog 收集器(RFC 3164,UDP 或 tcp://)。可选开启 — 未设置地址前不发送任何数据。',+ sl_ph: '主机:端口 或 tcp://主机:端口',+ ask_title: '连接询问',+ ask_hint: '将新出站连接挂起,直到您允许/拒绝 — 类似 Little Snitch 的弹窗。需要 Linux + NFQUEUE + root。',+ ask_timeout: '超时',+ ask_failopen: '失败开放(超时放行 — 较不安全)',+ ask_unavailable: '此系统不支持询问模式',+ ask_not_running: '询问模式已启用但未运行 — 请查看后端日志',+ gs_title: 'IOC 节点同步',+ gs_hint: '每 5 分钟向显式配对的 Snitch 实例推送加盐 Merkle 证明包 — 仅哈希承诺,绝不发送原始指标。',+ gs_peers_ph: '主机:端口,逗号分隔',+ gs_privacy: '可选的集群共享 — 数据包只发送给此处列出的节点。',}