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.9 KB
Raw Blame
/**
 * Snitch — Français 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: 'Graphe',
  nav_map: 'Carte',

  // Badge de statut / Status badge
  status_connected: 'En direct',
  status_connecting: 'Connexion…',
  status_disconnected: 'Déconnecté',
  status_error: 'Erreur',
  lan_devices: n => `${n} appareil${n > 1 ? 's' : ''} LAN`,

  // Légende / Legend
  legend_alert: 'Alerte',
  legend_unknown: 'Inconnu',
  legend_router: 'Routeur',
  legend_phone: 'Téléphone',
  legend_pc: 'PC',
  legend_iot: 'IoT',
  legend_https: 'HTTPS',
  legend_tracking: 'Pistage',
  legend_cdn: 'CDN',
  legend_dns: 'DNS',

  // En-tête de barre latérale + stats / Sidebar header + stats
  app_name: 'SNITCH',
  tagline: 'Traquez chaque flux masqué.',
  footer_credit: 'Développé par aiXis',
  stat_lan: 'Appareils LAN',
  stat_ext: 'Hôtes ext.',
  stat_traffic: 'Trafic',

  // Sections de la barre latérale / Sidebar sections
  section_lan: n => `Appareils LAN (${n})`,
  section_ext: (n, total) => total ? `Hôtes externes (${n}/${total})` : `Hôtes externes (${n})`,
  section_packets: 'Flux récents',
  packets_filter: 'Filtrer par app, hôte, protocole…',
  packets_none: 'Aucun trafic correspondant dans le flux',

  // Étiquettes des champs de détail de nœud / Node detail field labels
  field_ip: 'IP',
  field_mac: 'MAC',
  field_hostname: 'Nom d\'hôte',
  field_vendor: 'Fabricant',
  field_type: 'Type',
  field_country: 'Pays',
  field_city: 'Ville',
  field_org: 'Org',
  field_category: 'Catégorie',
  field_traffic: 'Trafic',
  field_packets: 'Paquets',
  processes: 'Processus',
  online: 'en ligne',
  offline: 'hors ligne',

  // Recherche / Search
  search_placeholder: 'Rechercher hôte, IP, pays…',
  cat_all: 'Tout',
  cat_unknown: 'Inconnu',
  cat_alerted: 'Alertes',
  cat_safe: 'Sûr',
  cat_tracking: 'Pistage',
  cat_cdn: 'CDN',
  cat_dns: 'DNS',
  cat_admin: 'Admin',
  cat_local: 'Local',
  cat_lan_device: 'Appareil LAN',
  cat_other: 'Autre',

  // FR: Noms de nœuds + indices d'identification affichés à l'utilisateur.
  // EN: Node names + identification hints shown to the user.
  node_local: 'Cet appareil',
  hint_local: "C'est CETTE machine — celle qui fait tourner Snitch. Tout ce qu'elle envoie ou reçoit rayonne depuis le centre du graphe.",
  unidentified: 'non identifié',
  devtype_router: 'Routeur',
  devtype_phone: 'Téléphone',
  devtype_pc: 'Ordinateur',
  devtype_tv: 'TV',
  devtype_iot: 'Objet connecté',
  devtype_unknown: 'Type inconnu',
  hint_unidentified: "Pas encore identifié — son nom apparaîtra s'il s'annonce (DNS/mDNS) ou si son fabricant est connu. Si vous ne le reconnaissez pas, vérifiez la liste des clients de votre box/routeur.",
  hint_unresolved: "Pas encore nommé — le domaine apparaîtra quand une réponse DNS ou un handshake TLS le révélera.",
  hint_private_mac: "Adresse MAC privée (aléatoire) — iOS/Android/Windows masquent la vraie, le fabricant ne peut pas être identifié. C'est un comportement de confidentialité normal.",
  hint_gateway: "C'est votre box/routeur — TOUT votre trafic internet passe physiquement par elle, donc la voir communiquer est normal et attendu.",
  hint_lan_idle: "Vu sur votre réseau via la table de voisinage — aucune donnée échangée. Une arête en pointillés signifie « présent », pas « en train de communiquer ».",
  hint_lan_active: b => `${b} échangés — le plus souvent des annonces automatiques (Bonjour/mDNS, partage de fichiers). À surveiller si le volume grimpe.`,
  ext_empty: "Aucune connexion externe pour l'instant — tout hôte contacté par votre machine apparaîtra ici.",
  legend_edge_solid: 'trait plein = trafic',
  legend_edge_dashed: 'pointillés = vu, sans données',
  legend_ring_safe: 'anneau vert = identifié, sûr',
  legend_ring_warn: 'anneau orange = suspect',
  legend_ring_crit: 'anneau rouge = alerte',
  legend_ring_none: 'sans anneau = non identifié, neutre',
  legend_perimeter: 'périmètre LAN',
  perim_lan: 'RÉSEAU LOCAL',

  // Panneau d'alertes / Alert panel
  alerts_title: 'Alertes',
  alerts_total: 'total',
  alerts_empty: "Aucune alerte pour l'instant",
  alert_NEW_HOST: 'Nouvel hôte',
  alert_SUSPICIOUS_PROCESS: 'Processus suspect',
  alert_SUSPICIOUS_PORT: 'Port suspect',
  alert_BEACON: 'Beacon C2',
  alert_VOLUME_SPIKE: 'Pic de trafic',
  alert_NEW_LAN_DEVICE: 'Nouvel appareil',
  alert_DEVICE_OFFLINE: 'Appareil hors ligne',
  alert_MEDIA_EXFIL: 'Exfiltration média',
  alert_PORT_SCAN: 'Scan de ports',
  alert_UPLOAD_SPIKE: 'Pic d\'envoi',
  alert_WATCHLIST_HIT: 'Correspondance watchlist',
  alertmsg_NEW_HOST: d => `Nouvel hôte contacté : ${d.host || d.ip}`,
  alertmsg_SUSPICIOUS_PROCESS: d => `Processus suspect : ${d.process} → ${d.host || d.ip}`,
  alertmsg_SUSPICIOUS_PORT: d => `Port suspect ${d.port} (${d.reason}) → ${d.host || d.ip}`,
  alertmsg_BEACON: d => `Régularité type beacon : intervalle ~${d.interval_s}s vers ${d.host || d.ip}`,
  alertmsg_VOLUME_SPIKE: d => `Pic de données vers ${d.host || d.ip} : ${Math.round((d.bytes || 0) / 1024)} Ko en ${d.window_s}s`,
  alertmsg_PORT_SCAN: d => `Scan de ports : ${d.source || d.ip} a touché ${d.ports}+ ports en ${d.window_s}s`,
  alertmsg_MEDIA_EXFIL: d => `Exfiltration ${d.device === 'camera' ? 'caméra' : 'micro'} suspectée : ${d.process} → ${d.host || d.ip}`,
  alertmsg_NEW_LAN_DEVICE: d => `Nouvel appareil sur le réseau : ${d.host || d.ip}`,
  alertmsg_DEVICE_OFFLINE: d => `Appareil hors ligne : ${d.host || d.ip}`,
  alertmsg_UPLOAD_SPIKE: d => `Pic d\'envoi : ${d.process} a envoyé ${d.mb} Mo en ${d.window_s}s`,
  alertmsg_WATCHLIST_HIT: d => `Watchlist : ${d.match} (${d.host || d.ip}) — ${d.process || 'processus inconnu'}`,
  time_just_now: "à l'instant",
  time_seconds: n => `il y a ${n}s`,
  time_minutes: n => `il y a ${n}min`,
  time_hours: n => `il y a ${n}h`,

  // Score de confidentialité / Privacy score
  privacy_title: 'Score de confidentialité',
  privacy_critical_label: 'Critique',
  privacy_excellent_label: 'Excellent',
  privacy_risk_factors: n => `${n} facteur${n !== 1 ? 's' : ''} de risque`,
  privacy_more_factors: n => `+${n} autre${n > 1 ? 's' : ''} facteur${n > 1 ? 's' : ''}`,
  privacy_label_excellent: 'Excellent',
  privacy_label_good: 'Bon',
  privacy_label_average: 'Moyen',
  privacy_label_weak: 'Faible',
  privacy_label_critical: 'Critique',

  // Timeline
  timeline_packets: n => `${n.toLocaleString('fr-FR')} paquets`,
  timeline_alerts: n => `${n} alerte${n > 1 ? 's' : ''}`,
  timeline_live: 'Direct',

  // Bascule de capture / Capture toggle
  capture_stop: 'Arrêter',
  capture_start: 'Démarrer',
  capture_stopping: 'Arrêt…',
  capture_starting: 'Démarrage…',
  capture_error_title: "Échec de la capture — aucun trafic ne s'affichera",
  capture_error_hint: "Relancez Snitch avec les droits de capture (admin sous Windows — Npcap requis, sudo sous macOS/Linux) ou appuyez sur Démarrer pour réessayer.",

  // Filtre de ports / Port filter
  port_filter: 'Ports',
  port_all: 'Tous les ports',
  port_placeholder: 'Ajouter un port (ex: 443)',
  port_invalid: 'Port invalide',

  // Export
  export_btn: 'Exporter',
  export_graph_json: 'Graphe (JSON)',
  export_graph_csv: 'Graphe (CSV)',
  export_alerts_json: 'Alertes (JSON)',
  export_alerts_csv: 'Alertes (CSV)',

  // Filtre de processus / Process filter
  process_filter: 'Applications',
  process_filter_hint: 'Cliquer pour masquer une app du graphe',
  process_none: 'Aucun processus détecté pour l\'instant',
  process_clear: 'Tout afficher',

  // Liste blanche d'IP / IP whitelist
  ip_whitelist: 'Confiance',
  ip_whitelist_hint: 'Les IP de confiance ne sont plus capturées ni affichées',
  ip_placeholder: 'Ajouter une IP (ex: 1.1.1.1)',
  ip_invalid: 'Adresse IP invalide',
  ip_clear: 'Vider la liste',
  whitelist_action: 'Marquer comme fiable',

  // Carte / Map
  map_you_approx: 'Vous (approx.)',
  map_you: 'Vous',
  map_located: n => `${n} hôte${n !== 1 ? 's' : ''} localisé${n !== 1 ? 's' : ''}`,
  map_no_geo: 'sans géo',

  // Libellés des facteurs de score / Scoring factor labels
  score_trackers: n => `${n} tracker${n > 1 ? 's' : ''} contacté${n > 1 ? 's' : ''}`,
  score_tracker_traffic: pct => `${pct}% de trafic vers des trackers`,
  score_ad_networks: n => `${n} régie${n > 1 ? 's' : ''} publicitaire${n > 1 ? 's' : ''}`,
  score_beacons: n => `${n} comportement${n > 1 ? 's' : ''} beacon`,
  score_susp_proc: n => `${n} processus suspect${n > 1 ? 's' : ''}`,
  score_susp_ports: n => `${n} port${n > 1 ? 's' : ''} dangereux`,
  score_critical_alerts: n => `${n} alerte${n > 1 ? 's' : ''} critique${n > 1 ? 's' : ''}`,
  score_warnings: n => `${n} alertes`,
  score_https_ratio: pct => `${pct}% de trafic HTTPS`,
  score_no_trackers: 'Aucun tracker détecté',

  // Réglages / Settings
  settings_title: 'Réglages',
  settings_saved: 'Enregistré',
  close: 'Fermer',
  settings_language: 'Langue / Language',
  theme_toggle: 'Thème clair / sombre',
  settings_retention: 'Rétention de l\'historique',
  settings_retention_hint: 'Durée de conservation du trafic et des alertes',
  settings_interface: 'Interface de capture',
  settings_interface_hint: 'Carte réseau écoutée (redémarre la capture)',
  settings_interface_auto: 'Auto (première non-loopback)',
  settings_upload: 'Seuil d\'alerte d\'envoi',
  settings_upload_hint: 'Alerter quand un processus envoie plus que ceci par minute',
  settings_off: 'Désactivé',
  watchlist_title: 'Liste de surveillance',
  watchlist_hint: 'Alerter dès qu\'un trafic touche ces IP ou domaines',
  watchlist_placeholder: '203.0.113.7 ou example.com',
  watchlist_add: 'Ajouter',
  watchlist_remove: 'Retirer',
  update_title: 'Mises à jour',
  update_checking: 'Vérification des mises à jour…',
  update_available: v => `Mise à jour disponible : v${v} — téléchargement`,
  update_downloading: p => `Téléchargement de la mise à jour… ${p}%`,
  update_ready: v => `v${v} téléchargée — redémarrer pour installer`,
  update_none: 'Snitch est à jour',
  update_error: 'Échec de la vérification',
  update_idle: 'Pas encore de vérification',
  update_restart: 'Redémarrer et installer',
  update_check_btn: 'Vérifier',
  update_auto: 'Vérifier automatiquement',
  update_privacy: 'Vérifie github.com pour les nouvelles versions — désactivable ci-dessous ; voir PRIVACY.md pour les autres appels opt-in.',
  geo_title: 'Base de géolocalisation',
  geo_present: dbs => `Installée : ${dbs}`,
  geo_none: 'Non installée — les IP ne sont pas géolocalisées',
  geo_download_btn: 'Télécharger DB-IP Lite (gratuit)',
  geo_consent: 'Télécharge ~50 Mo depuis db-ip.com (CC BY 4.0). Les autres appels sortants opt-in sont listés dans PRIVACY.md.',
  geo_downloading: 'Téléchargement…',
  geo_done: n => `${n} base(s) téléchargée(s)`,
  geo_failed: 'Échec du téléchargement — vérifiez la connexion',
  diag_title: 'Diagnostic',
  diag_hint: 'Logs et infos système pour les rapports de bug',
  diag_open_logs: 'Logs',
  diag_export: 'Exporter',
  settings_note: 'Tous les réglages sont stockés localement. Snitch n\'envoie rien à des tiers sans votre accord explicite.',
  nav_apps: 'Applications',
  ignore_alert: 'Ignorer ce type/cet hôte',

  // Vue applications / Apps view
  apps_empty: 'Aucun processus attribué pour l\'instant',
  apps_process: 'Processus',
  apps_destinations: 'Hôtes',
  apps_packets: 'Paquets',
  apps_volume: 'Volume',
  apps_top_dest: 'Destinations principales',
  apps_history_60m: 'Dernière heure (octets/min)',
  alertmsg_NEW_HOSTS: n => `${n} nouvel${n > 1 ? 'x' : ''} hôte${n > 1 ? 's' : ''} contacté${n > 1 ? 's' : ''}`,
  settings_autolaunch: 'Lancer à la connexion',
  settings_autolaunch_hint: 'Démarrer Snitch automatiquement à l\'ouverture de session',

  // Premier lancement / Onboarding
  onboard_title: 'Bienvenue dans Snitch',
  onboard_sub: 'Visualiseur de trafic réseau en temps réel — privé par conception.',
  onboard_priv_title: 'Tout reste sur cette machine',
  onboard_priv_body: 'Métadonnées de trafic, alertes et historique sont stockés dans une base SQLite locale. Pas de compte, pas de cloud, pas de télémétrie.',
  onboard_capture_title: 'Ce qui est capturé',
  onboard_capture_body: 'Les en-têtes de paquets seulement : IP de destination, ports, volumes, noms de processus, noms DNS et SNI TLS. Les contenus ne sont jamais lus.',
  onboard_out_title: 'Ce qui quitte la machine',
  onboard_out_body: 'Rien par défaut. Le seul appel sortant possible est le téléchargement de la base de géolocalisation, que vous déclenchez vous-même dans les Réglages.',
  onboard_go: 'Compris',

  // Pare-feu & sécurité / Firewall & security
  fw_title: 'Pare-feu & Sécurité',
  fw_lockdown: 'Mode lockdown',
  fw_lockdown_hint: 'Signaler & bloquer TOUT le trafic sortant (le LAN reste actif)',
  fw_lockdown_confirm: 'Activer le lockdown ? TOUT le trafic sortant sera signalé et bloqué jusqu\'à désactivation.',
  fw_lockdown_on: 'LOCKDOWN',
  fw_supported: p => `Orchestration du pare-feu OS sur ${p} — au mieux, exige des privilèges`,
  fw_unsupported: 'Pare-feu natif non géré ici — les règles sont de la visibilité seulement',
  fw_demo: 'démo — rien d\'appliqué',
  fw_kind: 'Type de règle',
  fw_value: 'Valeur',
  fw_kind_ip: 'IP / CIDR',
  fw_kind_domain: 'Domaine',
  fw_kind_process: 'Processus',
  fw_kind_port: 'Port',
  fw_ph_ip: '203.0.113.7 ou 185.0.0.0/8',
  fw_ph_domain: 'evil.example',
  fw_ph_process: 'app.exe',
  fw_ph_port: 'ex. 4444',
  fw_rules: 'Règles',
  fw_empty: 'Aucune règle — en ajouter une pour durcir les sorties',
  fw_blocked: n => `${n} tentative${n > 1 ? 's' : ''} vue${n > 1 ? 's' : ''}`,
  fw_applied: 'appliquée au pare-feu OS',
  fw_not_applied: 'visibilité seule (exige des privilèges)',
  fw_enable: 'Activer',
  fw_disable: 'Désactiver',
  fw_delete: 'Supprimer la règle',
  audit_title: 'Audit de sécurité',
  audit_refresh: 'Rafraîchir',
  audit_critical: 'critiques',
  audit_warning: 'avertissements',
  audit_risky: n => `${n} hôte(s) dans des pays à risque`,
  audit_loading: 'Chargement…',
  fw_forensics: 'Export forensique',
  block_action: 'Bloquer',
  proc_kill: 'Tuer le processus',
  proc_suspend: 'Suspendre / reprendre',
  save: 'Enregistrer',
  ti_title: 'Renseignement sur les menaces (opt-in)',
  ti_hint: 'Vérifier les nouveaux hôtes auprès d\'un fournisseur de réputation',
  ti_none: 'Désactivé',
  ti_key: 'Clé API',
  ti_key_ph: 'Votre clé API',
  ti_privacy: 'Appels sortants vers le fournisseur, uniquement pour les nouveaux hôtes publics. Désactivé par défaut — la clé est stockée localement.',
  wh_title: 'Webhook externe (opt-in)',
  wh_hint: 'Relayer les alertes warning/critiques vers Discord, Slack ou Telegram',
  wh_url: 'URL du webhook',
  wh_url_ph: 'https://discord.com/api/webhooks/… ou tout endpoint',
  wh_chat: 'Chat ID',
  wh_chat_ph: 'chat_id',
  wh_privacy: 'Les messages d\'alerte sont POSTés vers votre endpoint quand activé.',
  alert_BLOCKED_ATTEMPT: 'Tentative bloquée',
  alert_THREAT_HIT: 'Threat intel',
  alert_DNS_TUNNEL: 'Tunnel DNS',
  alert_CLEARTEXT: 'En clair',
  alert_BASELINE_DEVIATION: 'Déviation de baseline',
  alert_LOCKDOWN: 'Lockdown',
  alertmsg_BLOCKED_ATTEMPT: d => `Règle pare-feu correspondante : ${d.rule?.value || '?'} (${d.rule?.kind || '?'})${d.process ? ` par ${d.process}` : ''}`,
  alertmsg_THREAT_HIT: d => `Threat intel : ${d.ip} signalé ${d.verdict} (${d.provider} : ${d.detail || 'rapporté'})`,
  alertmsg_DNS_TUNNEL: d => `Tunnel DNS possible : nom surdimensionné interrogé par ${d.process}`,
  alertmsg_CLEARTEXT: d => `Connexion ${d.proto} non chiffrée vers ${d.host || d.ip} par ${d.process}`,
  alertmsg_BASELINE_DEVIATION: d => `${d.process} a contacté un nouveau pays : ${d.country}`,
  alertmsg_LOCKDOWN: () => 'Mode lockdown ACTIVÉ — tout le trafic sortant est bloqué',
  alert_BINARY_CHANGED: 'Binaire modifié',
  alert_NAME_MISMATCH: 'Mismatch nom',
  alert_MEM_RWX: 'Mémoire RWX',
  alertmsg_BINARY_CHANGED: d => `Exécutable modifié sur disque : ${d.exe || d.process || '?'}`,
  alertmsg_NAME_MISMATCH: d => `Mismatch nom/exe : ${d.process} → ${d.exe || '?'}`,
  alertmsg_MEM_RWX: d => `Mémoire inscriptible-exécutable dans ${d.process || `pid ${d.pid}`} : ${d.detail || ''}`,
  alert_why: 'Pourquoi ?',
  fw_action: 'Action',
  fw_action_block: 'Bloquer',
  fw_action_sinkhole: 'Sinkhole',
  iw_title: "Veille d'intégrité",
  iw_hint: 'Hash les exécutables des processus en réseau, signale les mismatches nom/exe et (Linux) les régions mémoire RWX.',
  iw_privacy: "Contrôles en lecture seule, 100 % locaux — rien n'est modifié ni envoyé.",
  alertmsg_MODULE_SUSPECT: d => `Chemin de module suspect dans ${d.process || 'processus'} : ${(d.modules || []).join(', ')}`,
  alertmsg_MODULE_CHANGED: d => `Intégrité des modules chargés modifiée dans ${d.process || 'processus'}`,
  alertmsg_MINING_STRATUM: d => `Protocole de minage (${d.marker || 'stratum'}) depuis ${d.process || `pid ${d.pid}`}`,
  alertmsg_MINING_SUSPECT: d => `Comportement de minage : ${d.process || `pid ${d.pid}`} — ${d.detail || 'port de pool + CPU soutenue'}`,
  alertmsg_SINKHOLE_HIT: d => `Tentative de connexion sinkholée : ${d.host || d.ip || '?'}`,
  alertmsg_INJECT_SUSPECT: d => `Suspicion de module injecté dans le pid ${d.pid} : ${(d.paths || []).join(', ')}`,
  fw_action_throttle: 'Brider',
  fw_rate: 'Débit (kbit/s)',
  fw_rate_hint: 'Limite de débit sortant en kbit/s (tc Linux)',
  ioc_title: 'Paquet IOC communautaire',
  ioc_export: 'Exporter',
  ioc_hint: "Partage les indicateurs en filtre de Bloom bruité — les valeurs en clair ne quittent jamais le fichier. Vérifications d'import probabilistes.",
  ioc_import_ph: 'Coller un paquet IOC reçu (JSON)…',
  ioc_check: 'Vérifier',
  ioc_hints: n => `${n} destination(s) correspondent au paquet (probabiliste)`,
  ioc_clean: 'Aucune correspondance',
  ioc_bad: 'Paquet invalide',
  di_inspect: 'Inspection profonde (Frida)',
  di_result: 'Chemins de modules suspects :',
  di_clean: 'Aucun chemin de module suspect — propre, ou aucun connect() capturé.',
  di_failed: 'Inspection profonde impossible (frida non installé ou droits insuffisants)',
  ebpf_title: 'Sonde eBPF connect',
  ebpf_hint: 'Linux seulement — attribue les paquets des processus très courts que la table des sockets rate. Exige python3-bcc + root.',
  ebpf_privacy: "Les événements noyau restent locaux — attribution seule, rien n'est journalisé ni envoyé.",
  slm_title: 'Enrichissement LLM local',
  slm_hint: "Optionnel : enrichit les explications d'alertes avec un modèle compatible Ollama. Loopback seul — les endpoints distants sont rejetés.",
  slm_endpoint: 'Endpoint',
  slm_model: 'Modèle',
  slm_privacy: "Actif seulement si activé ; les métadonnées d'alerte vont à votre modèle local, jamais hors-machine.",
  slm_mode_ollama: 'Serveur Ollama',
  slm_mode_embedded: 'GGUF embarqué',
  slm_model_path: 'Fichier modèle (.gguf)',
  fw_profiles: 'Profils',
  fw_profiles_hint: 'Lots de règles en un clic — dépliés en règles ordinaires.',
  fw_profile_permissive: 'Permissif',
  fw_profile_balanced: 'Équilibré',
  fw_profile_strict: 'Strict',
  fw_pcap_empty: "Aucune trame capturée — l'anneau ne garde que le trafic récent",
  fw_pcap_hint: 'Télécharger les trames récentes en .pcap — tampon borné, lisible par Wireshark',
  bl_title: 'Import de blocklist',
  bl_hint: 'Transformer un fichier hosts ou une liste de domaines en règles pare-feu (max 500).',
  bl_source: 'Source',
  bl_src_file: 'Fichier',
  bl_src_url: 'URL',
  bl_import: 'Importer',
  bl_url_confirm: "Fetcher cette URL fait émettre à Snitch une requête SORTANTE — l'une des rares possibles. Continuer ?",
  bl_result: (a, s) => `${a} règles ajoutées · ${s} déjà présentes`,
  bl_truncated: 'liste tronquée au plafond',
  bl_remote: 'fetch distant effectué',
  ar_title: "Règles d'alerte personnalisées",
  ar_hint: 'Lever des alertes CUSTOM_RULE sur vos propres motifs — ou « alerte + blocage » pour pare-feu automatique sur l\'hôte.',
  ar_name_ph: 'Nom de la règle (optionnel)',
  ar_field: 'Champ',
  ar_op: 'Opérateur',
  ar_value_ph: 'Valeur',
  ar_sev: 'Sévérité',
  ar_hits: n => `${n} déclenchements`,
  sev_info: 'info',
  sev_warning: 'avertissement',
  sev_critical: 'critique',
  pair_title: 'Pairing distant (LAN)',
  pair_hint: 'Permettre aux appareils du LAN de joindre cette API — jeton toujours exigé.',
  pair_lan_ips: ips => `Joignable sur : ${ips}`,
  pair_port: p => `port ${p}`,
  pair_restart: 'Appliqué au prochain redémarrage du backend — un socket actif ne peut être re-lié.',
  pair_privacy: 'Loopback uniquement par défaut ; activer expose l\'API au LAN (jeton toujours exigé).',
  sb_title: 'Sandbox sans réseau',
  sb_hint: 'Exécuter un binaire avec zéro égress réseau — observer sans exposition.',
  sb_path: "Chemin de l'exécutable",
  sb_run: 'Détoner',
  sb_done: code => `Exécuté en sandbox — sortie ${code}`,
  sb_failed: 'Sandbox indisponible sur cette plateforme',
  alertmsg_CUSTOM_RULE: d => `Règle personnalisée déclenchée : ${d.rule?.name || 'règle sans nom'}`,
  alert_TLS_CERT: 'Certificat TLS',
  alert_HIGH_ENTROPY: 'Haute entropie',
  alert_ICMP_TUNNEL: 'Tunnel ICMP',
  alert_ML_ANOMALY: 'Anomalie ML',
  alert_ASK_VERDICT: 'Verdict requis',
  alertmsg_TLS_CERT: d => `Anomalie du certificat TLS pour ${d.host || d.ip} : ${(d.reasons || []).join(', ')} (émetteur ${d.issuer || '?'})`,
  alertmsg_HIGH_ENTROPY: d => `Payload à haute entropie sur canal en clair ${d.process || '?'} → ${d.ip}:${d.port} (${d.entropy} bits/octet)`,
  alertmsg_ICMP_TUNNEL: d => `Tunnel ICMP possible : échos répétés à gros payload avec ${d.ip}`,
  alertmsg_ML_ANOMALY: d => `Anomalie ML de flux : ${d.process || '?'} → ${d.ip} (score ${d.score})`,
  alertmsg_ASK_VERDICT: d => `Verdict requis : ${d.process || 'un processus'} → ${d.remote_ip}:${d.remote_port}/${d.proto} (décision auto dans ${d.timeout_s}s)`,
  alertmsg_DGA_SUSPECT: d => `Domaine à aspect DGA ${d.label || d.name} (${(d.reasons || []).join(', ')})`,
  alertmsg_PROTO_MISMATCH: d => `Protocole déguisé : ${d.reason} — ${d.process || '?'} → ${d.ip}:${d.port}`,
  alert_act_block: "Bloquer l'IP",
  alert_act_kill: 'Tuer',
  alert_act_suspend: 'Suspendre',
  alert_act_allow: 'Autoriser',
  alert_act_deny: 'Refuser',
  alert_act_allow_perm: 'Toujours autoriser',
  alert_act_deny_perm: 'Toujours refuser',
  ar_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.',
  ks_title: 'Kill-switch de volume',
  ks_hint: 'Bloque l\u2019IP distante (vraie règle pare-feu) quand un pic d\u2019envoi se déclenche — désactivé par défaut',
}