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 — English UI dictionary.
*
* EN: Isolated locale file — one per language, so community contributors can
* add translations via a simple pull request (see CONTRIBUTING.md).
* Values may be strings or functions for interpolation: t('key', arg).
* FR: Fichier de locale isolé — un par langue, pour que la communauté puisse
* ajouter des traductions par simple pull request (cf. CONTRIBUTING.md).
* Les valeurs sont des chaînes ou des fonctions d'interpolation.
*/
export default { // Navigation
nav_graph: 'Graph',
nav_map: 'Map',
// Status badge / Badge de statut
status_connected: 'Live',
status_connecting: 'Connecting…',
status_disconnected: 'Disconnected',
status_error: 'Error',
lan_devices: n => `${n} device${n > 1 ? 's' : ''} LAN`,
// Legend / Légende
legend_alert: 'Alert',
legend_unknown: 'Unknown',
legend_router: 'Router',
legend_phone: 'Phone',
legend_pc: 'PC',
legend_iot: 'IoT',
legend_https: 'HTTPS',
legend_tracking: 'Tracking',
legend_cdn: 'CDN',
legend_dns: 'DNS',
// Sidebar header + stats / En-tête de barre latérale + stats
app_name: 'SNITCH',
tagline: "Track every hidden flow.",
footer_credit: 'Developed by aiXis',
stat_lan: 'LAN Devices',
stat_ext: 'Ext. hosts',
stat_traffic: 'Traffic',
// Sidebar sections / Sections de la barre latérale
section_lan: n => `LAN Devices (${n})`,
section_ext: (n, total) => total ? `External hosts (${n}/${total})` : `External hosts (${n})`,
section_packets: 'Recent traffic',
packets_filter: 'Filter by app, host, protocol…',
packets_none: 'No matching traffic in the live feed',
// Node detail field labels / Étiquettes des champs de détail de nœud
field_ip: 'IP',
field_mac: 'MAC',
field_hostname: 'Hostname',
field_vendor: 'Vendor',
field_type: 'Type',
field_country: 'Country',
field_city: 'City',
field_org: 'Org',
field_category: 'Category',
field_traffic: 'Traffic',
field_packets: 'Packets',
processes: 'Processes',
online: 'online',
offline: 'offline',
// Search / Recherche
search_placeholder: 'Search host, IP, country…',
cat_all: 'All',
cat_unknown: 'Unknown',
cat_alerted: 'Alerts',
cat_safe: 'Safe',
cat_tracking: 'Tracking',
cat_cdn: 'CDN',
cat_dns: 'DNS',
cat_admin: 'Admin',
cat_local: 'Local',
cat_lan_device: 'LAN device',
cat_other: 'Other',
// EN: Node names + identification hints shown to the user.
// FR: Noms de nœuds + indices d'identification affichés à l'utilisateur.
node_local: 'This Device',
hint_local: 'This is THIS machine — the one running Snitch. Everything it sends or receives radiates from the center of the graph.',
unidentified: 'unidentified',
devtype_router: 'Router',
devtype_phone: 'Phone',
devtype_pc: 'Computer',
devtype_tv: 'TV',
devtype_iot: 'IoT device',
devtype_unknown: 'Unknown type',
hint_unidentified: "Not identified yet — its name appears when it announces itself (DNS/mDNS) or its MAC vendor is known. If you don't recognize it, check your router's client list.",
hint_unresolved: 'Not yet named — the domain appears when a DNS answer or TLS handshake reveals it.',
hint_private_mac: 'Private (randomized) MAC address — iOS/Android/Windows hide the real one, so the vendor can\'t be identified. This is normal privacy behavior.',
hint_gateway: 'This is your internet box/router — ALL your traffic physically passes through it, so seeing it communicate is normal and expected.',
hint_lan_idle: 'Seen on your network via the neighbour table — no data exchanged. A dashed edge means "present", not "talking".',
hint_lan_active: b => `${b} exchanged — usually automatic announcements (Bonjour/mDNS, file sharing). Watch it if the volume climbs.`,
ext_empty: "No external connections yet — anything your machine talks to will appear here.",
legend_edge_solid: 'solid line = traffic',
legend_edge_dashed: 'dashed = seen, no data',
legend_ring_safe: 'green ring = identified, safe',
legend_ring_warn: 'amber ring = suspicious',
legend_ring_crit: 'red ring = alert',
legend_ring_none: 'no ring = unidentified, neutral',
legend_perimeter: 'LAN perimeter',
perim_lan: 'LOCAL NETWORK',
// Alert panel / Panneau d'alertes
alerts_title: 'Alerts',
alerts_total: 'total',
alerts_empty: 'No alerts yet',
alert_NEW_HOST: 'New host',
alert_SUSPICIOUS_PROCESS: 'Suspicious process',
alert_SUSPICIOUS_PORT: 'Suspicious port',
alert_BEACON: 'Beacon C2',
alert_VOLUME_SPIKE: 'Traffic spike',
alert_NEW_LAN_DEVICE: 'New device',
alert_DEVICE_OFFLINE: 'Device offline',
alert_MEDIA_EXFIL: 'Media exfiltration',
alert_PORT_SCAN: 'Port scan',
alert_UPLOAD_SPIKE: 'Upload spike',
alert_WATCHLIST_HIT: 'Watchlist hit',
// EN: Full alert messages built from backend codes + details — the backend
// only sends type + params, never prose.
// FR: Messages d'alerte complets construits depuis les codes + détails du
// backend — le backend n'envoie que type + paramètres, jamais de prose.
alertmsg_NEW_HOST: d => `New host contacted: ${d.host || d.ip}`,
alertmsg_SUSPICIOUS_PROCESS: d => `Suspicious process: ${d.process} → ${d.host || d.ip}`,
alertmsg_SUSPICIOUS_PORT: d => `Suspicious port ${d.port} (${d.reason}) → ${d.host || d.ip}`,
alertmsg_BEACON: d => `Beacon-like regularity: ~${d.interval_s}s interval to ${d.host || d.ip}`,
alertmsg_VOLUME_SPIKE: d => `Data spike to ${d.host || d.ip}: ${Math.round((d.bytes || 0) / 1024)} KB in ${d.window_s}s`,
alertmsg_MEDIA_EXFIL: d => `Suspected ${d.device} exfiltration: ${d.process} → ${d.host || d.ip}`,
alertmsg_NEW_LAN_DEVICE: d => `New device on the network: ${d.host || d.ip}`,
alertmsg_DEVICE_OFFLINE: d => `Device went offline: ${d.host || d.ip}`,
alertmsg_PORT_SCAN: d => `Port scan: ${d.source || d.ip} touched ${d.ports}+ ports in ${d.window_s}s`,
alertmsg_UPLOAD_SPIKE: d => `Upload spike: ${d.process} sent ${d.mb} MB in ${d.window_s}s`,
alertmsg_WATCHLIST_HIT: d => `Watchlist hit: ${d.match} (${d.host || d.ip}) — ${d.process || 'unknown process'}`,
time_just_now: 'just now',
time_seconds: n => `${n}s ago`,
time_minutes: n => `${n}min ago`,
time_hours: n => `${n}h ago`,
// Privacy score / Score de confidentialité
privacy_title: 'Privacy Score',
privacy_critical_label: 'Critical',
privacy_excellent_label: 'Excellent',
privacy_risk_factors: n => `${n} risk factor${n !== 1 ? 's' : ''}`,
privacy_more_factors: n => `+${n} more factor${n > 1 ? 's' : ''}`,
privacy_label_excellent: 'Excellent',
privacy_label_good: 'Good',
privacy_label_average: 'Average',
privacy_label_weak: 'Weak',
privacy_label_critical: 'Critical',
// Timeline
timeline_packets: n => `${n.toLocaleString()} packets`,
timeline_alerts: n => `${n} alert${n > 1 ? 's' : ''}`,
timeline_live: 'Live',
// Capture toggle / Bascule de capture
capture_stop: 'Stop',
capture_start: 'Start',
capture_stopping: 'Stopping…',
capture_starting: 'Starting…',
capture_error_title: 'Capture failed — no traffic will show',
capture_error_hint: 'Restart Snitch with capture privileges (admin on Windows — Npcap required, sudo on macOS/Linux) or press Start to retry.',
// Port filter / Filtre de ports
port_filter: 'Ports',
port_all: 'All ports',
port_placeholder: 'Add port (e.g. 443)',
port_invalid: 'Invalid port',
// Export
export_btn: 'Export',
export_graph_json: 'Graph (JSON)',
export_graph_csv: 'Graph (CSV)',
export_alerts_json: 'Alerts (JSON)',
export_alerts_csv: 'Alerts (CSV)',
// Process filter / Filtre de processus
process_filter: 'Apps',
process_filter_hint: 'Click to hide app from graph',
process_none: 'No processes detected yet',
process_clear: 'Show all apps',
// IP whitelist / Liste blanche d'IP
ip_whitelist: 'Trusted',
ip_whitelist_hint: 'Trusted IPs are no longer captured or shown',
ip_placeholder: 'Add IP (e.g. 1.1.1.1)',
ip_invalid: 'Invalid IP address',
ip_clear: 'Clear whitelist',
whitelist_action: 'Mark as trusted',
// Map / Carte
map_you_approx: 'You (approx.)',
map_you: 'You',
map_located: n => `${n} located host${n !== 1 ? 's' : ''}`,
map_no_geo: 'no geo',
// Scoring factor labels / Libellés des facteurs de score
score_trackers: n => `${n} tracker${n > 1 ? 's' : ''} contacted`,
score_tracker_traffic: pct => `${pct}% traffic to trackers`,
score_ad_networks: n => `${n} ad network${n > 1 ? 's' : ''}`,
score_beacons: n => `${n} beacon behavior${n > 1 ? 's' : ''}`,
score_susp_proc: n => `${n} suspicious process${n > 1 ? 'es' : ''}`,
score_susp_ports: n => `${n} dangerous port${n > 1 ? 's' : ''}`,
score_critical_alerts: n => `${n} critical alert${n > 1 ? 's' : ''}`,
score_warnings: n => `${n} warnings`,
score_https_ratio: pct => `${pct}% HTTPS traffic`,
score_no_trackers: 'No trackers detected',
// Settings / Réglages
settings_title: 'Settings',
settings_saved: 'Saved',
close: 'Close',
settings_language: 'Language / Langue',
theme_toggle: 'Light / dark theme',
settings_retention: 'History retention',
settings_retention_hint: 'How long traffic & alert history is kept',
settings_interface: 'Capture interface',
settings_interface_hint: 'Which network adapter is sniffed (restart capture to apply)',
settings_interface_auto: 'Auto (first non-loopback)',
settings_upload: 'Upload alert threshold',
settings_upload_hint: 'Warn when one process uploads more than this per minute',
settings_off: 'Off',
watchlist_title: 'Watchlist',
watchlist_hint: 'Get alerted whenever traffic touches these IPs or domains',
watchlist_placeholder: '203.0.113.7 or example.com',
watchlist_add: 'Add',
watchlist_remove: 'Remove',
update_title: 'Updates',
update_checking: 'Checking for updates…',
update_available: v => `Update available: v${v} — downloading`,
update_downloading: p => `Downloading update… ${p}%`,
update_ready: v => `v${v} downloaded — restart to install`,
update_none: 'Snitch is up to date',
update_error: 'Update check failed',
update_idle: 'No check yet',
update_restart: 'Restart & install',
update_check_btn: 'Check now',
update_auto: 'Check automatically',
update_privacy: 'Checks github.com for new releases — opt-out below; see PRIVACY.md for the other opt-in calls.',
geo_title: 'Geolocation database',
geo_present: dbs => `Installed: ${dbs}`,
geo_none: 'Not installed — IPs are not geolocated',
geo_download_btn: 'Download DB-IP Lite (free)',
geo_consent: 'Downloads ~50 MB from db-ip.com (CC BY 4.0). Other opt-in outbound calls are listed in PRIVACY.md.',
geo_downloading: 'Downloading…',
geo_done: n => `Downloaded ${n} database(s)`,
geo_failed: 'Download failed — check your connection',
diag_title: 'Diagnostics',
diag_hint: 'Logs and system info for bug reports',
diag_open_logs: 'Logs',
diag_export: 'Export',
settings_note: 'All settings are stored locally. Snitch never sends data to third parties without your explicit opt-in.',
nav_apps: 'Apps',
ignore_alert: 'Ignore this alert type/host',
// Apps view / Vue applications
apps_empty: 'No process attributed yet',
apps_process: 'Process',
apps_destinations: 'Hosts',
apps_packets: 'Packets',
apps_volume: 'Volume',
apps_top_dest: 'Top destinations',
apps_history_60m: 'Last hour (bytes/min)',
alertmsg_NEW_HOSTS: n => `${n} new host${n > 1 ? 's' : ''} contacted`,
settings_autolaunch: 'Launch at login',
settings_autolaunch_hint: 'Start Snitch automatically when you sign in',
// Onboarding / Premier lancement
onboard_title: 'Welcome to Snitch',
onboard_sub: 'Real-time network traffic visualizer — private by design.',
onboard_priv_title: 'Everything stays on this machine',
onboard_priv_body: 'Traffic metadata, alerts and history are stored in a local SQLite database. No account, no cloud, no telemetry.',
onboard_capture_title: 'What is captured',
onboard_capture_body: 'Packet headers only: destination IPs, ports, volumes, process names, DNS names and TLS server names (SNI). Payloads are never read.',
onboard_out_title: 'What leaves the machine',
onboard_out_body: 'Nothing by default. The only possible outbound call is the geolocation database download, which you trigger yourself in Settings.',
onboard_go: 'Got it',
// Firewall & security / Pare-feu & sécurité
fw_title: 'Firewall & Security',
fw_lockdown: 'Lockdown mode',
fw_lockdown_hint: 'Flag & block ALL outbound traffic (LAN stays up)',
fw_lockdown_confirm: 'Enable lockdown? ALL outbound traffic will be flagged and blocked until you turn it off.',
fw_lockdown_on: 'LOCKDOWN',
fw_supported: p => `OS firewall orchestration on ${p} — best effort, needs privileges`,
fw_unsupported: 'Native firewall not supported here — rules are visibility only',
fw_demo: 'demo — nothing applied',
fw_kind: 'Rule type',
fw_value: 'Value',
fw_kind_ip: 'IP / CIDR',
fw_kind_domain: 'Domain',
fw_kind_process: 'Process',
fw_kind_port: 'Port',
fw_ph_ip: '203.0.113.7 or 185.0.0.0/8',
fw_ph_domain: 'evil.example',
fw_ph_process: 'app.exe',
fw_ph_port: 'e.g. 4444',
fw_rules: 'Rules',
fw_empty: 'No rules — add one to harden outbound traffic',
fw_blocked: n => `${n} attempt${n > 1 ? 's' : ''} seen`,
fw_applied: 'applied to OS firewall',
fw_not_applied: 'visibility only (needs privileges)',
fw_enable: 'Enable',
fw_disable: 'Disable',
fw_delete: 'Delete rule',
audit_title: 'Security audit',
audit_refresh: 'Refresh',
audit_critical: 'critical',
audit_warning: 'warnings',
audit_risky: n => `${n} host(s) in high-risk countries`,
audit_loading: 'Loading…',
fw_forensics: 'Forensics export',
block_action: 'Block',
proc_kill: 'Kill process',
proc_suspend: 'Suspend / resume',
save: 'Save',
ti_title: 'Threat intelligence (opt-in)',
ti_hint: 'Check newly-seen hosts against a reputation provider',
ti_none: 'Disabled',
ti_key: 'API key',
ti_key_ph: 'Your API key',
ti_privacy: 'Outbound calls to the provider, only for newly-seen public hosts. Disabled by default — the key is stored locally.',
wh_title: 'External webhook (opt-in)',
wh_hint: 'Forward critical/warning alerts to Discord, Slack or Telegram',
wh_url: 'Webhook URL',
wh_url_ph: 'https://discord.com/api/webhooks/… or any endpoint',
wh_chat: 'Chat ID',
wh_chat_ph: 'chat_id',
wh_privacy: 'Alert messages are POSTed to your endpoint when enabled.',
alert_BLOCKED_ATTEMPT: 'Blocked attempt',
alert_THREAT_HIT: 'Threat intel',
alert_DNS_TUNNEL: 'DNS tunnel',
alert_CLEARTEXT: 'Cleartext',
alert_BASELINE_DEVIATION: 'Baseline deviation',
alert_LOCKDOWN: 'Lockdown',
alertmsg_BLOCKED_ATTEMPT: d => `Firewall rule matched: ${d.rule?.value || '?'} (${d.rule?.kind || '?'})${d.process ? ` by ${d.process}` : ''}`,
alertmsg_THREAT_HIT: d => `Threat intel: ${d.ip} flagged ${d.verdict} (${d.provider}: ${d.detail || 'reported'})`,
alertmsg_DNS_TUNNEL: d => `Possible DNS tunneling: oversized name queried by ${d.process}`,
alertmsg_CLEARTEXT: d => `Unencrypted ${d.proto} connection to ${d.host || d.ip} by ${d.process}`,
alertmsg_BASELINE_DEVIATION: d => `${d.process} contacted a new country: ${d.country}`,
alertmsg_LOCKDOWN: () => 'Lockdown mode ENABLED — all outbound traffic blocked',
alert_BINARY_CHANGED: 'Binary changed',
alert_NAME_MISMATCH: 'Name mismatch',
alert_MEM_RWX: 'RWX memory',
alertmsg_BINARY_CHANGED: d => `Executable modified on disk: ${d.exe || d.process || '?'}`,
alertmsg_NAME_MISMATCH: d => `Name/exe mismatch: ${d.process} → ${d.exe || '?'}`,
alertmsg_MEM_RWX: d => `Writable-executable memory in ${d.process || `pid ${d.pid}`}: ${d.detail || ''}`,
alert_why: 'Why?',
fw_action: 'Action',
fw_action_block: 'Block',
fw_action_sinkhole: 'Sinkhole',
iw_title: 'Integrity watch',
iw_hint: 'Hash executables of networked processes, flag name/exe mismatches and (Linux) RWX memory regions.',
iw_privacy: 'All checks are read-only local inspection — nothing is modified or sent.',
alertmsg_MODULE_SUSPECT: d => `Suspicious module path in ${d.process || 'process'}: ${(d.modules || []).join(', ')}`,
alertmsg_MODULE_CHANGED: d => `Loaded-module integrity changed in ${d.process || 'process'}`,
alertmsg_MINING_STRATUM: d => `Cryptomining protocol (${d.marker || 'stratum'}) from ${d.process || `pid ${d.pid}`}`,
alertmsg_MINING_SUSPECT: d => `Mining behaviour: ${d.process || `pid ${d.pid}`} — ${d.detail || 'pool port + sustained CPU'}`,
alertmsg_SINKHOLE_HIT: d => `Sinkholed connection attempted: ${d.host || d.ip || '?'}`,
alertmsg_INJECT_SUSPECT: d => `Injected-module suspicion in pid ${d.pid}: ${(d.paths || []).join(', ')}`,
fw_action_throttle: 'Throttle',
fw_rate: 'Rate (kbit/s)',
fw_rate_hint: 'Egress rate limit in kbit/s (Linux tc)',
ioc_title: 'Community IOC pack',
ioc_export: 'Export pack',
ioc_hint: 'Shares indicators as a noised Bloom filter — raw values never leave the file. Import checks are probabilistic.',
ioc_import_ph: 'Paste a received IOC pack (JSON)…',
ioc_check: 'Check',
ioc_hints: n => `${n} destination(s) match the pack (probabilistic)`,
ioc_clean: 'No match',
ioc_bad: 'Invalid pack',
di_inspect: 'Deep inspect (Frida)',
di_result: 'Suspicious module paths:',
di_clean: 'No suspicious module path — clean, or no connect() captured.',
di_failed: 'Deep inspection failed (frida not installed or insufficient rights)',
ebpf_title: 'eBPF connect probe',
ebpf_hint: 'Linux only — attributes packets from very short-lived processes that the socket table misses. Needs python3-bcc + root.',
ebpf_privacy: 'Kernel events stay local — attribution only, nothing is logged or sent.',
slm_title: 'Local LLM enrichment',
slm_hint: 'Optional: enriches alert explanations with an Ollama-compatible model. Loopback only — remote endpoints are rejected.',
slm_endpoint: 'Endpoint',
slm_model: 'Model',
slm_privacy: 'Runs only when enabled; alert metadata goes to your local model, never off-machine.',
slm_mode_ollama: 'Ollama server',
slm_mode_embedded: 'Embedded GGUF',
slm_model_path: 'Model file (.gguf)',
fw_profiles: 'Profiles',
fw_profiles_hint: 'One-tap policy bundles — expanded into ordinary rules.',
fw_profile_permissive: 'Permissive',
fw_profile_balanced: 'Balanced',
fw_profile_strict: 'Strict',
fw_pcap_empty: 'No frames captured yet — the ring holds recent traffic only',
fw_pcap_hint: 'Download recent raw frames as .pcap — bounded ring buffer, Wireshark-ready',
bl_title: 'Blocklist import',
bl_hint: 'Turn a hosts file or domain list into firewall rules (max 500).',
bl_source: 'Source',
bl_src_file: 'File',
bl_src_url: 'URL',
bl_import: 'Import',
bl_url_confirm: 'Fetching this URL makes Snitch emit an OUTBOUND request — one of the few it can ever send. Continue?',
bl_result: (a, s) => `${a} rules added · ${s} already present`,
bl_truncated: 'list truncated at the cap',
bl_remote: 'remote fetch performed',
ar_title: 'Custom alert rules',
ar_hint: 'Raise CUSTOM_RULE alerts on your own matches — or \'alert + block\' to auto-firewall matched hosts.',
ar_name_ph: 'Rule name (optional)',
ar_field: 'Field',
ar_op: 'Operator',
ar_value_ph: 'Value',
ar_sev: 'Severity',
ar_hits: n => `${n} hits`,
sev_info: 'info',
sev_warning: 'warning',
sev_critical: 'critical',
pair_title: 'Remote pairing (LAN)',
pair_hint: 'Let other devices on your LAN reach this API — token still required.',
pair_lan_ips: ips => `Reachable at: ${ips}`,
pair_port: p => `port ${p}`,
pair_restart: 'Applies at next backend restart — a live socket cannot be rebound.',
pair_privacy: 'Loopback-only by default; enabling exposes the API to your LAN with token auth still enforced.',
sb_title: 'Network-denial sandbox',
sb_hint: 'Run a binary with zero network egress — observe behaviour without exposure.',
sb_path: 'Executable path',
sb_run: 'Detonate',
sb_done: code => `Ran in sandbox — exit ${code}`,
sb_failed: 'Sandbox unavailable on this platform',
alertmsg_CUSTOM_RULE: d => `Custom rule matched: ${d.rule?.name || 'unnamed rule'}`,
alert_TLS_CERT: 'TLS certificate',
alert_HIGH_ENTROPY: 'High entropy',
alert_ICMP_TUNNEL: 'ICMP tunnel',
alert_ML_ANOMALY: 'ML anomaly',
alert_ASK_VERDICT: 'Verdict needed',
alertmsg_TLS_CERT: d => `TLS cert anomaly for ${d.host || d.ip}: ${(d.reasons || []).join(', ')} (issuer ${d.issuer || '?'})`,
alertmsg_HIGH_ENTROPY: d => `High-entropy payload on cleartext channel ${d.process || '?'} → ${d.ip}:${d.port} (${d.entropy} bits/byte)`,
alertmsg_ICMP_TUNNEL: d => `Possible ICMP tunnelling: repeated fat echo payloads with ${d.ip}`,
alertmsg_ML_ANOMALY: d => `ML flow anomaly: ${d.process || '?'} → ${d.ip} (score ${d.score})`,
alertmsg_ASK_VERDICT: d => `Verdict needed: ${d.process || 'a process'} → ${d.remote_ip}:${d.remote_port}/${d.proto} (auto-decision in ${d.timeout_s}s)`,
alertmsg_DGA_SUSPECT: d => `DGA-looking domain ${d.label || d.name} (${(d.reasons || []).join(', ')})`,
alertmsg_PROTO_MISMATCH: d => `Protocol mismatch: ${d.reason} — ${d.process || '?'} → ${d.ip}:${d.port}`,
alert_act_block: 'Block IP',
alert_act_kill: 'Kill',
alert_act_suspend: 'Suspend',
alert_act_allow: 'Allow',
alert_act_deny: 'Deny',
alert_act_allow_perm: 'Allow always',
alert_act_deny_perm: 'Deny always',
ar_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.',
ks_title: 'Volume kill-switch',
ks_hint: 'Auto-block the remote IP (real firewall rule) when an upload spike fires — off by default',
}