Skip to content

Real-time network monitor + outbound firewall — see & block every connection. Privacy-first, local-first, Rust fleet agent, SIEM exports, 8 languages. / Moniteur réseau temps réel + pare-feu sortant, agent de flotte Rust, exports SIEM. 100 % local.

23.0 KB
Raw Blame
/**
 * Snitch — deutsches UI-Wörterbuch.
 *
 * 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: 'Karte',

  // Status badge
  status_connected: 'Live',
  status_connecting: 'Verbinde…',
  status_disconnected: 'Getrennt',
  status_error: 'Fehler',
  lan_devices: n => `${n} LAN-Gerät${n > 1 ? 'e' : ''}`,

  // Legend / Legende
  legend_alert: 'Alarm',
  legend_unknown: 'Unbekannt',
  legend_router: 'Router',
  legend_phone: 'Telefon',
  legend_pc: 'PC',
  legend_iot: 'IoT',
  legend_https: 'HTTPS',
  legend_tracking: 'Tracking',
  legend_cdn: 'CDN',
  legend_dns: 'DNS',

  // Sidebar header + stats
  app_name: 'SNITCH',
  tagline: 'Jeden verborgenen Datenfluss aufspüren.',
  footer_credit: 'Entwickelt von aiXis',
  stat_lan: 'LAN-Geräte',
  stat_ext: 'Ext. Hosts',
  stat_traffic: 'Verkehr',

  // Sidebar sections
  section_lan: n => `LAN-Geräte (${n})`,
  section_ext: (n, total) => total ? `Externe Hosts (${n}/${total})` : `Externe Hosts (${n})`,
  section_packets: 'Aktueller Verkehr',
  packets_filter: 'Nach App, Host, Protokoll filtern…',
  packets_none: 'Kein passender Verkehr im Live-Feed',

  // Node detail field labels
  field_ip: 'IP',
  field_mac: 'MAC',
  field_hostname: 'Hostname',
  field_vendor: 'Hersteller',
  field_type: 'Typ',
  field_country: 'Land',
  field_city: 'Stadt',
  field_org: 'Organisation',
  field_category: 'Kategorie',
  field_traffic: 'Verkehr',
  field_packets: 'Pakete',
  processes: 'Prozesse',
  online: 'online',
  offline: 'offline',

  // Search / Suche
  search_placeholder: 'Host, IP, Land suchen…',
  cat_all: 'Alle',
  cat_unknown: 'Unbekannt',
  cat_alerted: 'Alarme',
  cat_safe: 'Sicher',
  cat_tracking: 'Tracking',
  cat_cdn: 'CDN',
  cat_dns: 'DNS',
  cat_admin: 'Admin',
  cat_local: 'Lokal',
  cat_lan_device: 'LAN-Gerät',
  cat_other: 'Sonstiges',

  // Node names + hints / Knotennamen + Hinweise
  node_local: 'Dieses Gerät',
  hint_local: 'Das ist DIESES Gerät — der Rechner, auf dem Snitch läuft. Alles, was es sendet oder empfängt, strahlt vom Zentrum des Graphen aus.',
  unidentified: 'nicht identifiziert',
  devtype_router: 'Router',
  devtype_phone: 'Telefon',
  devtype_pc: 'Computer',
  devtype_tv: 'Fernseher',
  devtype_iot: 'IoT-Gerät',
  devtype_unknown: 'Unbekannter Typ',
  hint_unidentified: 'Noch nicht identifiziert — der Name erscheint, sobald es sich meldet (DNS/mDNS) oder sein MAC-Hersteller bekannt ist. Wenn Sie es nicht kennen, prüfen Sie die Client-Liste Ihres Routers.',
  hint_unresolved: 'Noch unbenannt — die Domain erscheint, sobald eine DNS-Antwort oder ein TLS-Handshake sie verrät.',
  hint_private_mac: 'Private (zufällige) MAC-Adresse — iOS/Android/Windows verbergen die echte, daher kann der Hersteller nicht ermittelt werden. Normales Datenschutzverhalten.',
  hint_gateway: 'Das ist Ihre Internetbox/Ihr Router — IHR gesamter Verkehr läuft physisch darüber, es ist also normal, ihn kommunizieren zu sehen.',
  hint_lan_idle: 'Über die Nachbartabelle im Netz gesehen — keine Daten ausgetauscht. Eine gestrichelte Kante bedeutet „vorhanden“, nicht „spricht“.',
  hint_lan_active: b => `${b} ausgetauscht — meist automatische Meldungen (Bonjour/mDNS, Dateifreigabe). Beobachten, wenn das Volumen steigt.`,
  ext_empty: 'Noch keine externen Verbindungen — alles, womit Ihr Gerät spricht, erscheint hier.',
  legend_edge_solid: 'durchgezogene Linie = Verkehr',
  legend_edge_dashed: 'gestrichelt = gesehen, keine Daten',
  legend_ring_safe: 'grüner Ring = identifiziert, sicher',
  legend_ring_warn: 'gelber Ring = verdächtig',
  legend_ring_crit: 'roter Ring = Alarm',
  legend_ring_none: 'kein Ring = unidentifiziert, neutral',
  legend_perimeter: 'LAN-Perimeter',
  perim_lan: 'LOKALES NETZ',

  // Alert panel / Alarm-Panel
  alerts_title: 'Alarme',
  alerts_total: 'gesamt',
  alerts_empty: 'Noch keine Alarme',
  alert_NEW_HOST: 'Neuer Host',
  alert_SUSPICIOUS_PROCESS: 'Verdächtiger Prozess',
  alert_SUSPICIOUS_PORT: 'Verdächtiger Port',
  alert_BEACON: 'Beacon C2',
  alert_VOLUME_SPIKE: 'Verkehrsspitze',
  alert_NEW_LAN_DEVICE: 'Neues Gerät',
  alert_DEVICE_OFFLINE: 'Gerät offline',
  alert_MEDIA_EXFIL: 'Medien-Exfiltration',
  alert_PORT_SCAN: 'Port-Scan',
  alert_UPLOAD_SPIKE: 'Upload-Spitze',
  alert_WATCHLIST_HIT: 'Watchlist-Treffer',
  alertmsg_NEW_HOST: d => `Neuer Host kontaktiert: ${d.host || d.ip}`,
  alertmsg_SUSPICIOUS_PROCESS: d => `Verdächtiger Prozess: ${d.process} → ${d.host || d.ip}`,
  alertmsg_SUSPICIOUS_PORT: d => `Verdächtiger Port ${d.port} (${d.reason}) → ${d.host || d.ip}`,
  alertmsg_BEACON: d => `Beacon-ähnliche Regelmäßigkeit: Intervall ~${d.interval_s}s zu ${d.host || d.ip}`,
  alertmsg_VOLUME_SPIKE: d => `Datenspitze zu ${d.host || d.ip}: ${Math.round((d.bytes || 0) / 1024)} KB in ${d.window_s}s`,
  alertmsg_MEDIA_EXFIL: d => `Vermutete ${d.device}-Exfiltration: ${d.process} → ${d.host || d.ip}`,
  alertmsg_NEW_LAN_DEVICE: d => `Neues Gerät im Netz: ${d.host || d.ip}`,
  alertmsg_DEVICE_OFFLINE: d => `Gerät offline gegangen: ${d.host || d.ip}`,
  alertmsg_PORT_SCAN: d => `Port-Scan: ${d.source || d.ip} berührte ${d.ports}+ Ports in ${d.window_s}s`,
  alertmsg_UPLOAD_SPIKE: d => `Upload-Spitze: ${d.process} sendete ${d.mb} MB in ${d.window_s}s`,
  alertmsg_WATCHLIST_HIT: d => `Watchlist-Treffer: ${d.match} (${d.host || d.ip}) — ${d.process || 'unbekannter Prozess'}`,
  time_just_now: 'gerade eben',
  time_seconds: n => `vor ${n}s`,
  time_minutes: n => `vor ${n} Min.`,
  time_hours: n => `vor ${n} Std.`,

  // Privacy score / Datenschutz-Score
  privacy_title: 'Datenschutz-Score',
  privacy_critical_label: 'Kritisch',
  privacy_excellent_label: 'Exzellent',
  privacy_risk_factors: n => `${n} Risikofaktor${n !== 1 ? 'en' : ''}`,
  privacy_more_factors: n => `+${n} weitere${n > 1 ? ' Faktoren' : 'r Faktor'}`,
  privacy_label_excellent: 'Exzellent',
  privacy_label_good: 'Gut',
  privacy_label_average: 'Mittel',
  privacy_label_weak: 'Schwach',
  privacy_label_critical: 'Kritisch',

  // Timeline
  timeline_packets: n => `${n.toLocaleString()} Pakete`,
  timeline_alerts: n => `${n} Alarm${n > 1 ? 'e' : ''}`,
  timeline_live: 'Live',

  // Capture toggle / Aufnahme-Schalter
  capture_stop: 'Stopp',
  capture_start: 'Start',
  capture_stopping: 'Stoppe…',
  capture_starting: 'Starte…',
  capture_error_title: 'Aufzeichnung fehlgeschlagen — es wird kein Traffic angezeigt',
  capture_error_hint: 'Snitch mit Aufzeichnungsrechten neu starten (Admin unter Windows — Npcap erforderlich, sudo unter macOS/Linux) oder zum Wiederholen Start drücken.',

  // Port filter / Port-Filter
  port_filter: 'Ports',
  port_all: 'Alle Ports',
  port_placeholder: 'Port hinzufügen (z. B. 443)',
  port_invalid: 'Ungültiger Port',

  // Export
  export_btn: 'Export',
  export_graph_json: 'Graph (JSON)',
  export_graph_csv: 'Graph (CSV)',
  export_alerts_json: 'Alarme (JSON)',
  export_alerts_csv: 'Alarme (CSV)',

  // Process filter / Prozess-Filter
  process_filter: 'Apps',
  process_filter_hint: 'Klicken, um App aus dem Graphen auszublenden',
  process_none: 'Noch keine Prozesse erkannt',
  process_clear: 'Alle Apps anzeigen',

  // IP whitelist / IP-Whitelist
  ip_whitelist: 'Vertrauenswürdig',
  ip_whitelist_hint: 'Vertrauenswürdige IPs werden nicht mehr aufgezeichnet oder angezeigt',
  ip_placeholder: 'IP hinzufügen (z. B. 1.1.1.1)',
  ip_invalid: 'Ungültige IP-Adresse',
  ip_clear: 'Whitelist leeren',
  whitelist_action: 'Als vertrauenswürdig markieren',

  // Map / Karte
  map_you_approx: 'Sie (ca.)',
  map_you: 'Sie',
  map_located: n => `${n} geolokalisierte${n !== 1 ? 'r' : ''} Host${n !== 1 ? 's' : ''}`,
  map_no_geo: 'keine Geo',

  // Scoring factor labels / Score-Faktoren
  score_trackers: n => `${n} Tracker kontaktiert`,
  score_tracker_traffic: pct => `${pct}% Verkehr zu Trackern`,
  score_ad_networks: n => `${n} Werbenetzwerk${n > 1 ? 'e' : ''}`,
  score_beacons: n => `${n} Beacon-Verhalten`,
  score_susp_proc: n => `${n} verdächtige${n > 1 ? 'r' : ''} Prozess${n > 1 ? 'e' : ''}`,
  score_susp_ports: n => `${n} gefährliche${n > 1 ? 'r' : ''} Port${n > 1 ? 's' : ''}`,
  score_critical_alerts: n => `${n} kritische${n > 1 ? 'r' : ''} Alarm${n > 1 ? 'e' : ''}`,
  score_warnings: n => `${n} Warnungen`,
  score_https_ratio: pct => `${pct}% HTTPS-Verkehr`,
  score_no_trackers: 'Keine Tracker erkannt',

  // Settings / Einstellungen
  settings_title: 'Einstellungen',
  settings_saved: 'Gespeichert',
  close: 'Schließen',
  settings_language: 'Sprache / Language',
  theme_toggle: 'Helles / dunkles Design',
  settings_retention: 'Verlaufs-Aufbewahrung',
  settings_retention_hint: 'Wie lange Verkehrs- & Alarmverlauf aufbewahrt wird',
  settings_interface: 'Aufnahme-Schnittstelle',
  settings_interface_hint: 'Welcher Netzwerkadapter abgehört wird (Aufnahme neu starten zum Anwenden)',
  settings_interface_auto: 'Auto (erste Nicht-Loopback)',
  settings_upload: 'Upload-Alarm-Schwelle',
  settings_upload_hint: 'Warnen, wenn ein Prozess pro Minute mehr hochlädt',
  settings_off: 'Aus',
  watchlist_title: 'Watchlist',
  watchlist_hint: 'Alarm erhalten, sobald Verkehr diese IPs oder Domains berührt',
  watchlist_placeholder: '203.0.113.7 oder example.com',
  watchlist_add: 'Hinzufügen',
  watchlist_remove: 'Entfernen',
  update_title: 'Updates',
  update_checking: 'Suche nach Updates…',
  update_available: v => `Update verfügbar: v${v} — wird geladen`,
  update_downloading: p => `Update wird geladen… ${p}%`,
  update_ready: v => `v${v} geladen — Neustart zum Installieren`,
  update_none: 'Snitch ist aktuell',
  update_error: 'Update-Prüfung fehlgeschlagen',
  update_idle: 'Noch keine Prüfung',
  update_restart: 'Neustart & installieren',
  update_check_btn: 'Jetzt prüfen',
  update_auto: 'Automatisch prüfen',
  update_privacy: 'Prüft github.com auf neue Versionen — unten abschaltbar; weitere Opt-in-Aufrufe in PRIVACY.md.',
  geo_title: 'Geolokalisierungs-Datenbank',
  geo_present: dbs => `Installiert: ${dbs}`,
  geo_none: 'Nicht installiert — IPs werden nicht geolokalisiert',
  geo_download_btn: 'DB-IP Lite herunterladen (kostenlos)',
  geo_consent: 'Lädt ~50 MB von db-ip.com herunter (CC BY 4.0). Weitere optionale ausgehende Aufrufe stehen in PRIVACY.md.',
  geo_downloading: 'Lade herunter…',
  geo_done: n => `${n} Datenbank(en) geladen`,
  geo_failed: 'Download fehlgeschlagen — Verbindung prüfen',
  diag_title: 'Diagnose',
  diag_hint: 'Logs und Systeminfo für Fehlerberichte',
  diag_open_logs: 'Logs',
  diag_export: 'Export',
  settings_note: 'Alle Einstellungen werden lokal gespeichert. Snitch sendet ohne dein explizites Opt-in nie Daten an Dritte.',
  nav_apps: 'Apps',
  ignore_alert: 'Diesen Alarmtyp/Host ignorieren',

  // Apps view / App-Ansicht
  apps_empty: 'Noch kein Prozess zugeordnet',
  apps_process: 'Prozess',
  apps_destinations: 'Hosts',
  apps_packets: 'Pakete',
  apps_volume: 'Volumen',
  apps_top_dest: 'Top-Ziele',
  apps_history_60m: 'Letzte Stunde (Bytes/min)',
  alertmsg_NEW_HOSTS: n => `${n} neue${n > 1 ? '' : 'r'} Host${n > 1 ? 's' : ''} kontaktiert`,
  settings_autolaunch: 'Beim Anmelden starten',
  settings_autolaunch_hint: 'Snitch automatisch beim Anmelden starten',

  // Onboarding
  onboard_title: 'Willkommen bei Snitch',
  onboard_sub: 'Echtzeit-Netzwerkverkehr-Visualisierer — datenschutzfreundlich von Grund auf.',
  onboard_priv_title: 'Alles bleibt auf diesem Gerät',
  onboard_priv_body: 'Verkehrs-Metadaten, Alarme und Verlauf werden in einer lokalen SQLite-Datenbank gespeichert. Kein Konto, keine Cloud, keine Telemetrie.',
  onboard_capture_title: 'Was aufgezeichnet wird',
  onboard_capture_body: 'Nur Paket-Header: Ziel-IPs, Ports, Volumen, Prozessnamen, DNS-Namen und TLS-Servernamen (SNI). Inhalte werden nie gelesen.',
  onboard_out_title: 'Was das Gerät verlässt',
  onboard_out_body: 'Standardmäßig nichts. Der einzige mögliche ausgehende Aufruf ist der Download der Geolokalisierungs-Datenbank, den Sie selbst in den Einstellungen auslösen.',
  onboard_go: 'Verstanden',

  // Firewall & security / Firewall & Sicherheit
  fw_title: 'Firewall & Sicherheit',
  fw_lockdown: 'Lockdown-Modus',
  fw_lockdown_hint: 'ALLEN ausgehenden Verkehr melden & blockieren (LAN bleibt aktiv)',
  fw_lockdown_confirm: 'Lockdown aktivieren? ALLER ausgehender Verkehr wird gemeldet und blockiert, bis Sie ihn ausschalten.',
  fw_lockdown_on: 'LOCKDOWN',
  fw_supported: p => `OS-Firewall-Orchestrierung auf ${p} — best effort, benötigt Rechte`,
  fw_unsupported: 'Native Firewall hier nicht unterstützt — Regeln sind nur Sichtbarkeit',
  fw_demo: 'Demo — nichts angewendet',
  fw_kind: 'Regeltyp',
  fw_value: 'Wert',
  fw_kind_ip: 'IP / CIDR',
  fw_kind_domain: 'Domain',
  fw_kind_process: 'Prozess',
  fw_kind_port: 'Port',
  fw_ph_ip: '203.0.113.7 oder 185.0.0.0/8',
  fw_ph_domain: 'evil.example',
  fw_ph_process: 'app.exe',
  fw_ph_port: 'z. B. 4444',
  fw_rules: 'Regeln',
  fw_empty: 'Keine Regeln — eine hinzufügen, um ausgehenden Verkehr zu härten',
  fw_blocked: n => `${n} Versuch${n > 1 ? 'e' : ''} gesehen`,
  fw_applied: 'auf OS-Firewall angewendet',
  fw_not_applied: 'nur Sichtbarkeit (benötigt Rechte)',
  fw_enable: 'Aktivieren',
  fw_disable: 'Deaktivieren',
  fw_delete: 'Regel löschen',
  audit_title: 'Sicherheitsaudit',
  audit_refresh: 'Aktualisieren',
  audit_critical: 'kritisch',
  audit_warning: 'Warnungen',
  audit_risky: n => `${n} Host(s) in Hochrisikoländern`,
  audit_loading: 'Lädt…',
  fw_forensics: 'Forensik-Export',
  block_action: 'Blockieren',
  proc_kill: 'Prozess beenden',
  proc_suspend: 'Anhalten / fortsetzen',
  save: 'Speichern',
  ti_title: 'Threat Intelligence (opt-in)',
  ti_hint: 'Neu gesehene Hosts gegen einen Reputationsanbieter prüfen',
  ti_none: 'Deaktiviert',
  ti_key: 'API-Schlüssel',
  ti_key_ph: 'Ihr API-Schlüssel',
  ti_privacy: 'Ausgehende Aufrufe an den Anbieter, nur für neu gesehene öffentliche Hosts. Standardmäßig deaktiviert — der Schlüssel bleibt lokal.',
  wh_title: 'Externer Webhook (opt-in)',
  wh_hint: 'Kritische/Warn-Alarme an Discord, Slack oder Telegram weiterleiten',
  wh_url: 'Webhook-URL',
  wh_url_ph: 'https://discord.com/api/webhooks/… oder beliebiger Endpoint',
  wh_chat: 'Chat-ID',
  wh_chat_ph: 'chat_id',
  wh_privacy: 'Alarmmeldungen werden bei Aktivierung per POST an Ihren Endpoint gesendet.',
  alert_BLOCKED_ATTEMPT: 'Blockierter Versuch',
  alert_THREAT_HIT: 'Threat Intel',
  alert_DNS_TUNNEL: 'DNS-Tunnel',
  alert_CLEARTEXT: 'Klartext',
  alert_BASELINE_DEVIATION: 'Baseline-Abweichung',
  alert_LOCKDOWN: 'Lockdown',
  alertmsg_BLOCKED_ATTEMPT: d => `Firewall-Regel getroffen: ${d.rule?.value || '?'} (${d.rule?.kind || '?'})${d.process ? ` von ${d.process}` : ''}`,
  alertmsg_THREAT_HIT: d => `Threat Intel: ${d.ip} als ${d.verdict} gemeldet (${d.provider}: ${d.detail || 'gemeldet'})`,
  alertmsg_DNS_TUNNEL: d => `Mögliches DNS-Tunneling: überlanger Name angefragt von ${d.process}`,
  alertmsg_CLEARTEXT: d => `Unverschlüsselte ${d.proto}-Verbindung zu ${d.host || d.ip} von ${d.process}`,
  alertmsg_BASELINE_DEVIATION: d => `${d.process} kontaktierte ein neues Land: ${d.country}`,
  alertmsg_LOCKDOWN: () => 'Lockdown-Modus AKTIVIERT — aller ausgehender Verkehr blockiert',
  alert_BINARY_CHANGED: 'Binärdatei geändert',
  alert_NAME_MISMATCH: 'Namens-Mismatch',
  alert_MEM_RWX: 'RWX-Speicher',
  alertmsg_BINARY_CHANGED: d => `Executable auf dem Datenträger geändert: ${d.exe || d.process || '?'}`,
  alertmsg_NAME_MISMATCH: d => `Name/Exe-Mismatch: ${d.process} → ${d.exe || '?'}`,
  alertmsg_MEM_RWX: d => `Beschreibbar-ausführbarer Speicher in ${d.process || `pid ${d.pid}`}: ${d.detail || ''}`,
  alert_why: 'Warum?',
  fw_action: 'Aktion',
  fw_action_block: 'Blockieren',
  fw_action_sinkhole: 'Sinkhole',
  iw_title: 'Integritätswache',
  iw_hint: 'Hasht Executables vernetzter Prozesse, meldet Name/Exe-Mismatches und (Linux) RWX-Speicherbereiche.',
  iw_privacy: 'Alle Prüfungen sind lokale, schreibgeschützte Inspektion — nichts wird geändert oder gesendet.',
  alertmsg_MODULE_SUSPECT: d => `Verdächtiger Modulpfad in ${d.process || 'Prozess'}: ${(d.modules || []).join(', ')}`,
  alertmsg_MODULE_CHANGED: d => `Integrität geladener Module geändert in ${d.process || 'Prozess'}`,
  alertmsg_MINING_STRATUM: d => `Krypto-Mining-Protokoll (${d.marker || 'stratum'}) von ${d.process || `pid ${d.pid}`}`,
  alertmsg_MINING_SUSPECT: d => `Mining-Verhalten: ${d.process || `pid ${d.pid}`} — ${d.detail || 'Pool-Port + anhaltende CPU'}`,
  alertmsg_SINKHOLE_HIT: d => `Versuchte Verbindung zu versenktem Ziel: ${d.host || d.ip || '?'}`,
  alertmsg_INJECT_SUSPECT: d => `Verdacht auf injiziertes Modul in pid ${d.pid}: ${(d.paths || []).join(', ')}`,
  fw_action_throttle: 'Drosseln',
  fw_rate: 'Rate (kbit/s)',
  fw_rate_hint: 'Ausgangs-Ratenlimit in kbit/s (Linux tc)',
  ioc_title: 'Community-IOC-Paket',
  ioc_export: 'Paket exportieren',
  ioc_hint: 'Teilt Indikatoren als verrauschten Bloom-Filter — Klartextwerte verlassen die Datei nie. Importprüfungen sind probabilistisch.',
  ioc_import_ph: 'Empfangenes IOC-Paket einfügen (JSON)…',
  ioc_check: 'Prüfen',
  ioc_hints: n => `${n} Ziel(e) entsprechen dem Paket (probabilistisch)`,
  ioc_clean: 'Keine Übereinstimmung',
  ioc_bad: 'Ungültiges Paket',
  di_inspect: 'Tiefeninspektion (Frida)',
  di_result: 'Verdächtige Modulpfade:',
  di_clean: 'Kein verdächtiger Modulpfad — sauber oder kein connect() erfasst.',
  di_failed: 'Tiefeninspektion fehlgeschlagen (frida nicht installiert oder fehlende Rechte)',
  ebpf_title: 'eBPF-Connect-Sonde',
  ebpf_hint: 'Nur Linux — ordnet Pakete sehr kurzlebiger Prozesse zu, die die Socket-Tabelle verpasst. Erfordert python3-bcc + root.',
  ebpf_privacy: 'Kernel-Ereignisse bleiben lokal — nur Zuordnung, nichts wird protokolliert oder gesendet.',
  slm_title: 'Lokale LLM-Anreicherung',
  slm_hint: 'Optional: reichert Alarm-Erklärungen mit einem Ollama-kompatiblen Modell an. Nur Loopback — entfernte Endpunkte werden abgelehnt.',
  slm_endpoint: 'Endpunkt',
  slm_model: 'Modell',
  slm_privacy: 'Läuft nur wenn aktiviert; Alarm-Metadaten gehen an Ihr lokales Modell, niemals von der Maschine weg.',
  slm_mode_ollama: 'Ollama-Server',
  slm_mode_embedded: 'Eingebettetes GGUF',
  slm_model_path: 'Modelldatei (.gguf)',
  fw_profiles: 'Profile',
  fw_profiles_hint: 'Ein-Klick-Richtlinienpakete — in gewöhnliche Regeln ausgerollt.',
  fw_profile_permissive: 'Permissiv',
  fw_profile_balanced: 'Ausgewogen',
  fw_profile_strict: 'Strikt',
  fw_pcap_empty: 'Noch keine Frames — der Ringpuffer hält nur aktuellen Verkehr',
  fw_pcap_hint: 'Letzte Rohframes als .pcap laden — begrenzter Ringpuffer, Wireshark-fertig',
  bl_title: 'Blockliste importieren',
  bl_hint: 'Hosts-Datei oder Domainliste in Firewall-Regeln umwandeln (max. 500).',
  bl_source: 'Quelle',
  bl_src_file: 'Datei',
  bl_src_url: 'URL',
  bl_import: 'Importieren',
  bl_url_confirm: 'Das Abrufen dieser URL lässt Snitch eine AUSGEHENDE Anfrage senden — eine der wenigen überhaupt. Fortfahren?',
  bl_result: (a, s) => `${a} Regeln hinzugefügt · ${s} bereits vorhanden`,
  bl_truncated: 'Liste am Limit gekürzt',
  bl_remote: 'Remote-Abruf durchgeführt',
  ar_title: 'Eigene Alarmregeln',
  ar_hint: 'CUSTOM_RULE-Alarme für eigene Muster — oder „Alarm + Block“ für automatische Firewall-Regeln.',
  ar_name_ph: 'Regelname (optional)',
  ar_field: 'Feld',
  ar_op: 'Operator',
  ar_value_ph: 'Wert',
  ar_sev: 'Schweregrad',
  ar_hits: n => `${n} Treffer`,
  sev_info: 'Info',
  sev_warning: 'Warnung',
  sev_critical: 'Kritisch',
  pair_title: 'Fernkopplung (LAN)',
  pair_hint: 'Anderen Geräten im LAN den Zugriff auf diese API erlauben — Token bleibt Pflicht.',
  pair_lan_ips: ips => `Erreichbar unter: ${ips}`,
  pair_port: p => `Port ${p}`,
  pair_restart: 'Gilt ab dem nächsten Backend-Neustart — ein aktiver Socket kann nicht neu gebunden werden.',
  pair_privacy: 'Standardmäßig nur Loopback; Aktivieren exponiert die API im LAN (Token-Auth bleibt).',
  sb_title: 'Sandbox ohne Netzwerk',
  sb_hint: 'Binärdatei mit null Netzwerk-Egress ausführen — Verhalten ohne Risiko beobachten.',
  sb_path: 'Pfad zur Programmdatei',
  sb_run: 'Ausführen',
  sb_done: code => `In Sandbox ausgeführt — Exit ${code}`,
  sb_failed: 'Sandbox auf dieser Plattform nicht verfügbar',
  alertmsg_CUSTOM_RULE: d => `Eigene Regel ausgelöst: ${d.rule?.name || 'unbenannte Regel'}`,
  alert_TLS_CERT: 'TLS-Zertifikat',
  alert_HIGH_ENTROPY: 'Hohe Entropie',
  alert_ICMP_TUNNEL: 'ICMP-Tunnel',
  alert_ML_ANOMALY: 'ML-Anomalie',
  alert_ASK_VERDICT: 'Entscheid nötig',
  alertmsg_TLS_CERT: d => `TLS-Zertifikatsanomalie für ${d.host || d.ip}: ${(d.reasons || []).join(', ')} (Aussteller ${d.issuer || '?'})`,
  alertmsg_HIGH_ENTROPY: d => `Hoch-Entropie-Payload auf Klartextkanal ${d.process || '?'} → ${d.ip}:${d.port} (${d.entropy} Bits/Byte)`,
  alertmsg_ICMP_TUNNEL: d => `Möglicher ICMP-Tunnel: wiederholte große Echo-Payloads mit ${d.ip}`,
  alertmsg_ML_ANOMALY: d => `ML-Flussanomalie: ${d.process || '?'} → ${d.ip} (Score ${d.score})`,
  alertmsg_ASK_VERDICT: d => `Entscheid nötig: ${d.process || 'ein Prozess'} → ${d.remote_ip}:${d.remote_port}/${d.proto} (Auto-Entscheid in ${d.timeout_s}s)`,
  alertmsg_DGA_SUSPECT: d => `DGA-verdächtige Domain ${d.label || d.name} (${(d.reasons || []).join(', ')})`,
  alertmsg_PROTO_MISMATCH: d => `Getarntes Protokoll: ${d.reason} — ${d.process || '?'} → ${d.ip}:${d.port}`,
  alert_act_block: 'IP blockieren',
  alert_act_kill: 'Beenden',
  alert_act_suspend: 'Anhalten',
  alert_act_allow: 'Erlauben',
  alert_act_deny: 'Verweigern',
  alert_act_allow_perm: 'Immer erlauben',
  alert_act_deny_perm: 'Immer verweigern',
  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.',
  ks_title: 'Volumen-Kill-Switch',
  ks_hint: 'Blockiert die Remote-IP (echte Firewall-Regel) bei einem Upload-Spike — standardmäßig aus',
}