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.3 KB
Raw Blame
/**
 * Snitch — Español 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 {  // Navegación
  nav_graph: 'Grafo',
  nav_map: 'Mapa',

  // Badge de estado
  status_connected: 'En directo',
  status_connecting: 'Conectando…',
  status_disconnected: 'Desconectado',
  status_error: 'Error',
  lan_devices: n => `${n} dispositivo${n > 1 ? 's' : ''} LAN`,

  // Leyenda
  legend_alert: 'Alerta',
  legend_unknown: 'Desconocido',
  legend_router: 'Router',
  legend_phone: 'Teléfono',
  legend_pc: 'PC',
  legend_iot: 'IoT',
  legend_https: 'HTTPS',
  legend_tracking: 'Rastreo',
  legend_cdn: 'CDN',
  legend_dns: 'DNS',

  // Cabecera + estadísticas de la barra lateral
  app_name: 'SNITCH',
  tagline: 'Vigila cada flujo oculto.',
  footer_credit: 'Desarrollado por aiXis',
  stat_lan: 'Dispositivos LAN',
  stat_ext: 'Hosts ext.',
  stat_traffic: 'Tráfico',

  // Secciones de la barra lateral
  section_lan: n => `Dispositivos LAN (${n})`,
  section_ext: (n, total) => total ? `Hosts externos (${n}/${total})` : `Hosts externos (${n})`,
  section_packets: 'Tráfico reciente',
  packets_filter: 'Filtrar por app, host, protocolo…',
  packets_none: 'Sin tráfico coincidente en el flujo',

  // Etiquetas de los campos de detalle de nodo
  field_ip: 'IP',
  field_mac: 'MAC',
  field_hostname: 'Nombre de host',
  field_vendor: 'Fabricante',
  field_type: 'Tipo',
  field_country: 'País',
  field_city: 'Ciudad',
  field_org: 'Org',
  field_category: 'Categoría',
  field_traffic: 'Tráfico',
  field_packets: 'Paquetes',
  processes: 'Procesos',
  online: 'en línea',
  offline: 'fuera de línea',

  // Búsqueda
  search_placeholder: 'Buscar host, IP, país…',
  cat_all: 'Todo',
  cat_unknown: 'Desconocido',
  cat_alerted: 'Alertas',
  cat_safe: 'Seguro',
  cat_tracking: 'Rastreo',
  cat_cdn: 'CDN',
  cat_dns: 'DNS',
  cat_admin: 'Admin',
  cat_local: 'Local',
  cat_lan_device: 'Dispositivo LAN',
  cat_other: 'Otro',

  node_local: 'Este dispositivo',
  hint_local: 'Esta es ESTA máquina — la que ejecuta Snitch. Todo lo que envía o recibe irradia desde el centro del grafo.',
  unidentified: 'sin identificar',
  devtype_router: 'Router',
  devtype_phone: 'Teléfono',
  devtype_pc: 'Ordenador',
  devtype_tv: 'TV',
  devtype_iot: 'Dispositivo IoT',
  devtype_unknown: 'Tipo desconocido',
  hint_unidentified: 'Aún no identificado — su nombre aparece cuando se anuncia (DNS/mDNS) o se conoce el fabricante de su MAC. Si no lo reconoces, revisa la lista de clientes de tu router.',
  hint_unresolved: 'Aún sin nombre — el dominio aparece cuando una respuesta DNS o un handshake TLS lo revela.',
  hint_private_mac: 'Dirección MAC privada (aleatorizada) — iOS/Android/Windows ocultan la real, así que el fabricante no se puede identificar. Es un comportamiento de privacidad normal.',
  hint_gateway: 'Esta es tu caja/router de internet — TODO tu tráfico pasa físicamente por él, así que verlo comunicar es normal y esperado.',
  hint_lan_idle: 'Visto en tu red vía la tabla de vecinos — sin datos intercambiados. Una arista discontinua significa « presente », no « hablando ».',
  hint_lan_active: b => `${b} intercambiados — normalmente anuncios automáticos (Bonjour/mDNS, compartición de archivos). Vigílalo si el volumen sube.`,
  ext_empty: 'Sin conexiones externas todavía — todo lo que hable tu máquina aparecerá aquí.',
  legend_edge_solid: 'línea sólida = tráfico',
  legend_edge_dashed: 'discontinua = visto, sin datos',
  legend_ring_safe: 'anillo verde = identificado, seguro',
  legend_ring_warn: 'anillo ámbar = sospechoso',
  legend_ring_crit: 'anillo rojo = alerta',
  legend_ring_none: 'sin anillo = no identificado, neutro',
  legend_perimeter: 'Perímetro LAN',
  perim_lan: 'RED LOCAL',

  // Panel de alertas
  alerts_title: 'Alertas',
  alerts_total: 'total',
  alerts_empty: 'Sin alertas por ahora',
  alert_NEW_HOST: 'Host nuevo',
  alert_SUSPICIOUS_PROCESS: 'Proceso sospechoso',
  alert_SUSPICIOUS_PORT: 'Puerto sospechoso',
  alert_BEACON: 'Beacon C2',
  alert_VOLUME_SPIKE: 'Pico de tráfico',
  alert_NEW_LAN_DEVICE: 'Dispositivo nuevo',
  alert_DEVICE_OFFLINE: 'Dispositivo fuera de línea',
  alert_MEDIA_EXFIL: 'Exfiltración de medios',
  alert_PORT_SCAN: 'Escaneo de puertos',
  alert_UPLOAD_SPIKE: 'Pico de subida',
  alert_WATCHLIST_HIT: 'Coincidencia watchlist',
  alertmsg_NEW_HOST: d => `Host nuevo contactado: ${d.host || d.ip}`,
  alertmsg_SUSPICIOUS_PROCESS: d => `Proceso sospechoso: ${d.process} → ${d.host || d.ip}`,
  alertmsg_SUSPICIOUS_PORT: d => `Puerto sospechoso ${d.port} (${d.reason}) → ${d.host || d.ip}`,
  alertmsg_BEACON: d => `Regularidad tipo beacon: intervalo ~${d.interval_s}s hacia ${d.host || d.ip}`,
  alertmsg_VOLUME_SPIKE: d => `Pico de datos hacia ${d.host || d.ip}: ${Math.round((d.bytes || 0) / 1024)} KB en ${d.window_s}s`,
  alertmsg_MEDIA_EXFIL: d => `Posible exfiltración de ${d.device === 'camera' ? 'cámara' : 'micrófono'}: ${d.process} → ${d.host || d.ip}`,
  alertmsg_NEW_LAN_DEVICE: d => `Nuevo dispositivo en la red: ${d.host || d.ip}`,
  alertmsg_DEVICE_OFFLINE: d => `Dispositivo desconectado: ${d.host || d.ip}`,
  alertmsg_PORT_SCAN: d => `Escaneo de puertos: ${d.source || d.ip} tocó ${d.ports}+ puertos en ${d.window_s}s`,
  alertmsg_UPLOAD_SPIKE: d => `Pico de subida: ${d.process} envió ${d.mb} MB en ${d.window_s}s`,
  alertmsg_WATCHLIST_HIT: d => `Watchlist: ${d.match} (${d.host || d.ip}) — ${d.process || 'proceso desconocido'}`,
  time_just_now: 'ahora mismo',
  time_seconds: n => `hace ${n}s`,
  time_minutes: n => `hace ${n}min`,
  time_hours: n => `hace ${n}h`,

  // Puntuación de privacidad
  privacy_title: 'Puntuación de privacidad',
  privacy_critical_label: 'Crítica',
  privacy_excellent_label: 'Excelente',
  privacy_risk_factors: n => `${n} factor${n !== 1 ? 'es' : ''} de riesgo`,
  privacy_more_factors: n => `+${n} factor${n > 1 ? 'es' : ''} más`,
  privacy_label_excellent: 'Excelente',
  privacy_label_good: 'Buena',
  privacy_label_average: 'Media',
  privacy_label_weak: 'Débil',
  privacy_label_critical: 'Crítica',

  // Timeline
  timeline_packets: n => `${n.toLocaleString()} paquetes`,
  timeline_alerts: n => `${n} alerta${n > 1 ? 's' : ''}`,
  timeline_live: 'En directo',

  // Botón de captura
  capture_stop: 'Detener',
  capture_start: 'Iniciar',
  capture_stopping: 'Deteniendo…',
  capture_starting: 'Iniciando…',
  capture_error_title: 'Error de captura: no se mostrará tráfico',
  capture_error_hint: 'Reinicia Snitch con privilegios de captura (administrador en Windows — Npcap requerido, sudo en macOS/Linux) o pulsa Iniciar para reintentar.',

  // Filtro de puertos
  port_filter: 'Puertos',
  port_all: 'Todos los puertos',
  port_placeholder: 'Añadir puerto (ej. 443)',
  port_invalid: 'Puerto inválido',

  // Exportar
  export_btn: 'Exportar',
  export_graph_json: 'Grafo (JSON)',
  export_graph_csv: 'Grafo (CSV)',
  export_alerts_json: 'Alertas (JSON)',
  export_alerts_csv: 'Alertas (CSV)',

  // Filtro de procesos
  process_filter: 'Apps',
  process_filter_hint: 'Clic para ocultar la app del grafo',
  process_none: 'Sin procesos detectados aún',
  process_clear: 'Mostrar todas las apps',

  // Lista blanca de IP
  ip_whitelist: 'De confianza',
  ip_whitelist_hint: 'Las IP de confianza ya no se capturan ni se muestran',
  ip_placeholder: 'Añadir IP (ej. 1.1.1.1)',
  ip_invalid: 'Dirección IP inválida',
  ip_clear: 'Vaciar la lista',
  whitelist_action: 'Marcar como de confianza',

  // Mapa
  map_you_approx: 'Tú (aprox.)',
  map_you: 'Tú',
  map_located: n => `${n} host${n !== 1 ? 's' : ''} localizado${n !== 1 ? 's' : ''}`,
  map_no_geo: 'sin geo',

  // Factores de la puntuación
  score_trackers: n => `${n} rastreador${n > 1 ? 'es' : ''} contactado${n > 1 ? 's' : ''}`,
  score_tracker_traffic: pct => `${pct}% del tráfico hacia rastreadores`,
  score_ad_networks: n => `${n} red${n > 1 ? 'es' : ''} publicitaria${n > 1 ? 's' : ''}`,
  score_beacons: n => `${n} comportamiento${n > 1 ? 's' : ''} tipo beacon`,
  score_susp_proc: n => `${n} proceso${n > 1 ? 's' : ''} sospechoso${n > 1 ? 's' : ''}`,
  score_susp_ports: n => `${n} puerto${n > 1 ? 's' : ''} peligroso${n > 1 ? 's' : ''}`,
  score_critical_alerts: n => `${n} alerta${n > 1 ? 's' : ''} crítica${n > 1 ? 's' : ''}`,
  score_warnings: n => `${n} avisos`,
  score_https_ratio: pct => `${pct}% de tráfico HTTPS`,
  score_no_trackers: 'Sin rastreadores detectados',

  // Ajustes
  settings_title: 'Ajustes',
  settings_saved: 'Guardado',
  close: 'Cerrar',
  settings_language: 'Idioma / Language',
  theme_toggle: 'Tema claro / oscuro',
  settings_retention: 'Retención del historial',
  settings_retention_hint: 'Cuánto tiempo se conserva el tráfico y las alertas',
  settings_interface: 'Interfaz de captura',
  settings_interface_hint: 'Qué adaptador de red se escucha (reinicia la captura)',
  settings_interface_auto: 'Auto (primera no-loopback)',
  settings_upload: 'Umbral de alerta de subida',
  settings_upload_hint: 'Avisar cuando un proceso suba más de esto por minuto',
  settings_off: 'Desactivado',
  watchlist_title: 'Lista de vigilancia',
  watchlist_hint: 'Alertar en cuanto el tráfico toque estas IP o dominios',
  watchlist_placeholder: '203.0.113.7 o example.com',
  watchlist_add: 'Añadir',
  watchlist_remove: 'Quitar',
  update_title: 'Actualizaciones',
  update_checking: 'Buscando actualizaciones…',
  update_available: v => `Actualización disponible: v${v} — descargando`,
  update_downloading: p => `Descargando actualización… ${p}%`,
  update_ready: v => `v${v} descargada — reiniciar para instalar`,
  update_none: 'Snitch está al día',
  update_error: 'Falló la comprobación',
  update_idle: 'Sin comprobación todavía',
  update_restart: 'Reiniciar e instalar',
  update_check_btn: 'Comprobar ahora',
  update_auto: 'Comprobar automáticamente',
  update_privacy: 'Consulta github.com para nuevas versiones — desactivable abajo; ver PRIVACY.md para las demás llamadas opt-in.',
  geo_title: 'Base de geolocalización',
  geo_present: dbs => `Instalada: ${dbs}`,
  geo_none: 'No instalada — las IP no se geolocalizan',
  geo_download_btn: 'Descargar DB-IP Lite (gratis)',
  geo_consent: 'Descarga ~50 MB de db-ip.com (CC BY 4.0). Las demás llamadas salientes opt-in están en PRIVACY.md.',
  geo_downloading: 'Descargando…',
  geo_done: n => `${n} base(s) descargada(s)`,
  geo_failed: 'Descarga fallida — revisa tu conexión',
  diag_title: 'Diagnóstico',
  diag_hint: 'Logs e info del sistema para informes de error',
  diag_open_logs: 'Logs',
  diag_export: 'Exportar',
  settings_note: 'Todos los ajustes se guardan localmente. Snitch no envía nada a terceros sin tu consentimiento explícito.',
  nav_apps: 'Aplicaciones',
  ignore_alert: 'Ignorar este tipo/este host',

  // Vista de aplicaciones
  apps_empty: 'Sin procesos atribuidos todavía',
  apps_process: 'Proceso',
  apps_destinations: 'Hosts',
  apps_packets: 'Paquetes',
  apps_volume: 'Volumen',
  apps_top_dest: 'Destinos principales',
  apps_history_60m: 'Última hora (bytes/min)',
  alertmsg_NEW_HOSTS: n => `${n} host${n > 1 ? 's' : ''} nuevo${n > 1 ? 's' : ''} contactado${n > 1 ? 's' : ''}`,
  settings_autolaunch: 'Iniciar al arrancar',
  settings_autolaunch_hint: 'Arrancar Snitch automáticamente al iniciar sesión',

  // Onboarding
  onboard_title: 'Bienvenido a Snitch',
  onboard_sub: 'Visualizador de tráfico de red en tiempo real — privado por diseño.',
  onboard_priv_title: 'Todo se queda en esta máquina',
  onboard_priv_body: 'Metadatos de tráfico, alertas e historial se guardan en una base SQLite local. Sin cuenta, sin nube, sin telemetría.',
  onboard_capture_title: 'Qué se captura',
  onboard_capture_body: 'Solo cabeceras de paquetes: IP de destino, puertos, volúmenes, nombres de proceso, nombres DNS y SNI TLS. Los contenidos nunca se leen.',
  onboard_out_title: 'Qué sale de la máquina',
  onboard_out_body: 'Nada por defecto. La única llamada saliente posible es la descarga de la base de geolocalización, que tú mismo lanzas en Ajustes.',
  onboard_go: 'Entendido',

  // Cortafuegos y seguridad / Firewall & security
  fw_title: 'Cortafuegos y Seguridad',
  fw_lockdown: 'Modo lockdown',
  fw_lockdown_hint: 'Señalar y bloquear TODO el tráfico saliente (la LAN sigue activa)',
  fw_lockdown_confirm: '¿Activar lockdown? TODO el tráfico saliente será señalado y bloqueado hasta desactivarlo.',
  fw_lockdown_on: 'LOCKDOWN',
  fw_supported: p => `Orquestación del cortafuegos del SO en ${p} — a mejor esfuerzo, requiere privilegios`,
  fw_unsupported: 'Cortafuegos nativo no soportado aquí — las reglas son solo visibilidad',
  fw_demo: 'demo — nada aplicado',
  fw_kind: 'Tipo de regla',
  fw_value: 'Valor',
  fw_kind_ip: 'IP / CIDR',
  fw_kind_domain: 'Dominio',
  fw_kind_process: 'Proceso',
  fw_kind_port: 'Puerto',
  fw_ph_ip: '203.0.113.7 o 185.0.0.0/8',
  fw_ph_domain: 'evil.example',
  fw_ph_process: 'app.exe',
  fw_ph_port: 'ej. 4444',
  fw_rules: 'Reglas',
  fw_empty: 'Sin reglas — añade una para endurecer las salidas',
  fw_blocked: n => `${n} intento${n > 1 ? 's' : ''} visto${n > 1 ? 's' : ''}`,
  fw_applied: 'aplicada al cortafuegos del SO',
  fw_not_applied: 'solo visibilidad (requiere privilegios)',
  fw_enable: 'Activar',
  fw_disable: 'Desactivar',
  fw_delete: 'Eliminar regla',
  audit_title: 'Auditoría de seguridad',
  audit_refresh: 'Actualizar',
  audit_critical: 'críticas',
  audit_warning: 'avisos',
  audit_risky: n => `${n} host(s) en países de riesgo`,
  audit_loading: 'Cargando…',
  fw_forensics: 'Exportación forense',
  block_action: 'Bloquear',
  proc_kill: 'Matar proceso',
  proc_suspend: 'Suspender / reanudar',
  save: 'Guardar',
  ti_title: 'Inteligencia de amenazas (opt-in)',
  ti_hint: 'Comprobar hosts nuevos contra un proveedor de reputación',
  ti_none: 'Desactivado',
  ti_key: 'Clave API',
  ti_key_ph: 'Tu clave API',
  ti_privacy: 'Llamadas salientes al proveedor, solo para hosts públicos nuevos. Desactivado por defecto — la clave se guarda localmente.',
  wh_title: 'Webhook externo (opt-in)',
  wh_hint: 'Reenviar alertas warning/críticas a Discord, Slack o Telegram',
  wh_url: 'URL del webhook',
  wh_url_ph: 'https://discord.com/api/webhooks/… o cualquier endpoint',
  wh_chat: 'Chat ID',
  wh_chat_ph: 'chat_id',
  wh_privacy: 'Los mensajes de alerta se envían por POST a tu endpoint cuando está activado.',
  alert_BLOCKED_ATTEMPT: 'Intento bloqueado',
  alert_THREAT_HIT: 'Threat intel',
  alert_DNS_TUNNEL: 'Túnel DNS',
  alert_CLEARTEXT: 'En claro',
  alert_BASELINE_DEVIATION: 'Desviación de baseline',
  alert_LOCKDOWN: 'Lockdown',
  alertmsg_BLOCKED_ATTEMPT: d => `Regla de cortafuegos coincidente: ${d.rule?.value || '?'} (${d.rule?.kind || '?'})${d.process ? ` por ${d.process}` : ''}`,
  alertmsg_THREAT_HIT: d => `Threat intel: ${d.ip} marcado ${d.verdict} (${d.provider}: ${d.detail || 'reportado'})`,
  alertmsg_DNS_TUNNEL: d => `Posible túnel DNS: nombre sobredimensionado consultado por ${d.process}`,
  alertmsg_CLEARTEXT: d => `Conexión ${d.proto} sin cifrar hacia ${d.host || d.ip} por ${d.process}`,
  alertmsg_BASELINE_DEVIATION: d => `${d.process} contactó un país nuevo: ${d.country}`,
  alertmsg_LOCKDOWN: () => 'Modo lockdown ACTIVADO — todo el tráfico saliente bloqueado',
  alert_BINARY_CHANGED: 'Binario modificado',
  alert_NAME_MISMATCH: 'Nombre no coincide',
  alert_MEM_RWX: 'Memoria RWX',
  alertmsg_BINARY_CHANGED: d => `Ejecutable modificado en disco: ${d.exe || d.process || '?'}`,
  alertmsg_NAME_MISMATCH: d => `Nombre/exe no coinciden: ${d.process} → ${d.exe || '?'}`,
  alertmsg_MEM_RWX: d => `Memoria escribible-ejecutable en ${d.process || `pid ${d.pid}`}: ${d.detail || ''}`,
  alert_why: '¿Por qué?',
  fw_action: 'Acción',
  fw_action_block: 'Bloquear',
  fw_action_sinkhole: 'Sinkhole',
  iw_title: 'Vigilancia de integridad',
  iw_hint: 'Hashea los ejecutables de procesos con red, señala nombres/exe que no coinciden y (Linux) regiones de memoria RWX.',
  iw_privacy: 'Comprobaciones de solo lectura, 100 % locales — nada se modifica ni se envía.',
  alertmsg_MODULE_SUSPECT: d => `Ruta de módulo sospechosa en ${d.process || 'proceso'}: ${(d.modules || []).join(', ')}`,
  alertmsg_MODULE_CHANGED: d => `Integridad de módulos cargados alterada en ${d.process || 'proceso'}`,
  alertmsg_MINING_STRATUM: d => `Protocolo de criptominería (${d.marker || 'stratum'}) desde ${d.process || `pid ${d.pid}`}`,
  alertmsg_MINING_SUSPECT: d => `Comportamiento de minería: ${d.process || `pid ${d.pid}`} — ${d.detail || 'puerto de pool + CPU sostenida'}`,
  alertmsg_SINKHOLE_HIT: d => `Conexión intentada hacia un destino hundido: ${d.host || d.ip || '?'}`,
  alertmsg_INJECT_SUSPECT: d => `Sospecha de módulo inyectado en pid ${d.pid}: ${(d.paths || []).join(', ')}`,
  fw_action_throttle: 'Limitar',
  fw_rate: 'Tasa (kbit/s)',
  fw_rate_hint: 'Límite de tasa de salida en kbit/s (tc Linux)',
  ioc_title: 'Paquete IOC comunitario',
  ioc_export: 'Exportar paquete',
  ioc_hint: 'Comparte indicadores como un filtro Bloom con ruido — los valores en claro nunca salen del archivo. Las comprobaciones de importación son probabilísticas.',
  ioc_import_ph: 'Pega un paquete IOC recibido (JSON)…',
  ioc_check: 'Comprobar',
  ioc_hints: n => `${n} destino(s) coinciden con el paquete (probabilístico)`,
  ioc_clean: 'Sin coincidencias',
  ioc_bad: 'Paquete inválido',
  di_inspect: 'Inspección profunda (Frida)',
  di_result: 'Rutas de módulos sospechosas:',
  di_clean: 'Sin rutas de módulo sospechosas — limpio o ningún connect() capturado.',
  di_failed: 'Inspección profunda fallida (frida no instalado o permisos insuficientes)',
  ebpf_title: 'Sonda eBPF connect',
  ebpf_hint: 'Solo Linux — atribuye paquetes de procesos muy efímeros que la tabla de sockets no captura. Requiere python3-bcc + root.',
  ebpf_privacy: 'Los eventos del kernel se quedan locales — solo atribución, nada se registra ni se envía.',
  slm_title: 'Enriquecimiento LLM local',
  slm_hint: 'Opcional: enriquece las explicaciones de alertas con un modelo compatible con Ollama. Solo loopback — endpoints remotos rechazados.',
  slm_endpoint: 'Endpoint',
  slm_model: 'Modelo',
  slm_privacy: 'Solo funciona si está activado; los metadatos de alertas van a tu modelo local, nunca fuera de la máquina.',
  slm_mode_ollama: 'Servidor Ollama',
  slm_mode_embedded: 'GGUF integrado',
  slm_model_path: 'Archivo de modelo (.gguf)',
  fw_profiles: 'Perfiles',
  fw_profiles_hint: 'Paquetes de políticas de un toque — expandidos en reglas ordinarias.',
  fw_profile_permissive: 'Permisivo',
  fw_profile_balanced: 'Equilibrado',
  fw_profile_strict: 'Estricto',
  fw_pcap_empty: 'Sin tramas capturadas — el anillo solo guarda tráfico reciente',
  fw_pcap_hint: 'Descargar tramas recientes como .pcap — búfer circular acotado, listo para Wireshark',
  bl_title: 'Importar blocklist',
  bl_hint: 'Convierte un archivo hosts o lista de dominios en reglas de firewall (máx. 500).',
  bl_source: 'Fuente',
  bl_src_file: 'Archivo',
  bl_src_url: 'URL',
  bl_import: 'Importar',
  bl_url_confirm: 'Descargar esta URL hace que Snitch emita una petición SALIENTE — una de las pocas que puede enviar. ¿Continuar?',
  bl_result: (a, s) => `${a} reglas añadidas · ${s} ya existentes`,
  bl_truncated: 'lista truncada al límite',
  bl_remote: 'descarga remota realizada',
  ar_title: 'Reglas de alerta personalizadas',
  ar_hint: 'Lanza alertas CUSTOM_RULE con tus propios patrones — o «alerta + bloqueo» para cortafuegos automático.',
  ar_name_ph: 'Nombre de la regla (opcional)',
  ar_field: 'Campo',
  ar_op: 'Operador',
  ar_value_ph: 'Valor',
  ar_sev: 'Severidad',
  ar_hits: n => `${n} coincidencias`,
  sev_info: 'info',
  sev_warning: 'aviso',
  sev_critical: 'crítica',
  pair_title: 'Emparejamiento remoto (LAN)',
  pair_hint: 'Permite que otros dispositivos de tu LAN alcancen esta API — el token sigue siendo obligatorio.',
  pair_lan_ips: ips => `Accesible en: ${ips}`,
  pair_port: p => `puerto ${p}`,
  pair_restart: 'Se aplica en el próximo reinicio del backend — un socket activo no puede reenlazarse.',
  pair_privacy: 'Solo loopback por defecto; activarlo expone la API a tu LAN con autenticación por token.',
  sb_title: 'Sandbox sin red',
  sb_hint: 'Ejecuta un binario con cero salida de red — observa sin exponerte.',
  sb_path: 'Ruta del ejecutable',
  sb_run: 'Detonar',
  sb_done: code => `Ejecutado en sandbox — salida ${code}`,
  sb_failed: 'Sandbox no disponible en esta plataforma',
  alertmsg_CUSTOM_RULE: d => `Regla personalizada activada: ${d.rule?.name || 'regla sin nombre'}`,
  alert_TLS_CERT: 'Certificado TLS',
  alert_HIGH_ENTROPY: 'Alta entropía',
  alert_ICMP_TUNNEL: 'Túnel ICMP',
  alert_ML_ANOMALY: 'Anomalía ML',
  alert_ASK_VERDICT: 'Veredicto requerido',
  alertmsg_TLS_CERT: d => `Anomalía del certificado TLS para ${d.host || d.ip}: ${(d.reasons || []).join(', ')} (emisor ${d.issuer || '?'})`,
  alertmsg_HIGH_ENTROPY: d => `Payload de alta entropía en canal en claro ${d.process || '?'} → ${d.ip}:${d.port} (${d.entropy} bits/byte)`,
  alertmsg_ICMP_TUNNEL: d => `Posible túnel ICMP: ecos repetidos con payloads grandes hacia ${d.ip}`,
  alertmsg_ML_ANOMALY: d => `Anomalía ML de flujo: ${d.process || '?'} → ${d.ip} (puntuación ${d.score})`,
  alertmsg_ASK_VERDICT: d => `Veredicto requerido: ${d.process || 'un proceso'} → ${d.remote_ip}:${d.remote_port}/${d.proto} (decisión auto en ${d.timeout_s}s)`,
  alertmsg_DGA_SUSPECT: d => `Dominio con aspecto de DGA ${d.label || d.name} (${(d.reasons || []).join(', ')})`,
  alertmsg_PROTO_MISMATCH: d => `Protocolo disfrazado: ${d.reason} — ${d.process || '?'} → ${d.ip}:${d.port}`,
  alert_act_block: 'Bloquear IP',
  alert_act_kill: 'Matar',
  alert_act_suspend: 'Suspender',
  alert_act_allow: 'Permitir',
  alert_act_deny: 'Denegar',
  alert_act_allow_perm: 'Permitir siempre',
  alert_act_deny_perm: 'Denegar siempre',
  ar_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í.',
  ks_title: 'Kill-switch de volumen',
  ks_hint: 'Bloquea la IP remota (regla de firewall real) cuando salta un pico de subida — desactivado por defecto',
}