Notmining AI Shield

1. Introducción

Notmining AI Shield es una extensión de navegador diseñada para actuar como un Data Loss Prevention (DLP) tanto para uso personal como en entornos corporativos. Monitoriza de forma pasiva la interacción de los usuarios con plataformas de Inteligencia Artificial (como ChatGPT, Claude, Copilot, etc.) y bloquea la filtración de datos sensibles como DNI, IBAN, contraseñas o expresiones regulares personalizadas.

2. Características Clave de Bloqueo

La extensión opera en la capa del navegador y aplica múltiples restricciones para asegurar que la información no salga del endpoint:

• Análisis de Portapapeles (Paste): Bloquea instantáneamente el copiado y pegado de datos sensibles, impidiendo que el usuario pueda introducir masivamente información protegida en el chat de la IA.
• Modo de Sobreescritura (Redacción / Data Masking): Permite configurar la extensión para que, en lugar de bloquear la acción por completo, enmascare automáticamente los datos sensibles detectados (sustituyéndolos por etiquetas personalizadas), permitiendo al usuario continuar su trabajo de forma segura y sin fricciones.
• Anti-Copia de PowerShell / Terminal: Detecta y bloquea el copiado y pegado de comandos de terminal, scripts o trazas de ejecución que podrían revelar la estructura de la red o configuraciones internas.
• Bloqueo de Subida de Ficheros: Impide la lectura de archivos confidenciales que el usuario intente arrastrar (Drag & Drop) o adjuntar haciendo clic en el chat de la IA.
• Monitorización Multipestaña: Protege de forma continua todas las pestañas activas que coincidan con los dominios objetivo configurados por el administrador.
• Sincronización Remota de Políticas: Permite configurar una URL centralizada desde donde la extensión descargará automáticamente las últimas reglas, expresiones regulares y configuraciones (soporta cifrado AES-256 para mayor seguridad).

Panel de configuración visible para el usuario final de la extensión.

Alerta mostrada al usuario cuando se bloquea un intento de filtración de datos.

3. Instalación para Usuarios (Paso a Paso)

Actualmente, la extensión se distribuye de forma privada mediante un archivo ZIP. Para instalarla en tu navegador personal de forma manual, sigue estos sencillos pasos:

1. Descarga el archivo: Haz clic en el botón de "Descargar extensión" (en la barra lateral) y guarda el archivo notmining-ai-shield.zip en tu ordenador.
2. Descomprime el archivo: Haz clic derecho sobre el ZIP descargado y selecciona "Extraer todo...". Guarda la carpeta extraída en un lugar seguro (por ejemplo, en tus Documentos). Importante: No borres esta carpeta después de la instalación.
3. Abre las extensiones:
   • En Chrome: Escribe chrome://extensions/ en la barra de direcciones y pulsa Enter.
   • En Edge: Escribe edge://extensions/ en la barra de direcciones y pulsa Enter.
4. Activa el Modo Desarrollador: En la esquina superior derecha (o inferior izquierda en Edge) de esa pantalla, verás un interruptor llamado Modo de desarrollador. Asegúrate de que esté activado.
5. Carga la extensión: Aparecerán tres nuevos botones en la parte superior. Haz clic en Cargar descomprimida (Load unpacked).
6. Selecciona la carpeta: Busca y selecciona la carpeta que extrajiste en el paso 2 (asegúrate de seleccionar la carpeta que contiene el archivo manifest.json en su interior).
7. ¡Listo!: La extensión Notmining AI Shield ya está instalada y activa. Te recomendamos anclarla a la barra superior haciendo clic en el icono del "rompecabezas" y marcando la chincheta (o el ojo en Edge) junto a la extensión.

4. Instalación y Despliegue para Administradores (GPO)

Para entornos Enterprise, la instalación manual no es viable. La extensión debe gestionarse e instalarse de forma centralizada y silenciosa en todos los endpoints de la organización mediante Políticas de Grupo (GPO) de Windows, utilizando el archivo schema.json.

4.1. Despliegue Silencioso de la Extensión (Force Install)

Para forzar la instalación de la extensión en todos los navegadores corporativos sin intervención del usuario, puedes elegir entre dos vías principales utilizando las plantillas administrativas de Google Chrome o Microsoft Edge (ADMX/ADML) instaladas en tu Controlador de Dominio:

Opción A: Vía Chrome Web Store / Edge Add-ons (Próximamente)

Esta es la opción recomendada, ya que garantizará que todos los endpoints reciban actualizaciones automáticas y transparentes. Una vez publicada:

1. Abre el Editor de Administración de Directivas de Grupo (GPMC).
2. Navega a: Configuración del equipo > Directivas > Plantillas administrativas > Google > Google Chrome > Extensiones (Para Edge: ... > Microsoft > Microsoft Edge > Extensiones).
3. Edita la directiva Configurar la lista de aplicaciones y extensiones instaladas por la fuerza (Control which extensions are installed silently).
4. Habilítala y añade el ID oficial de la extensión de la tienda correspondiente junto a la URL de actualización oficial (ej. [ID_EXTENSION];https://clients2.google.com/service/update2/crx para Chrome).

Opción B: Instalación Offline o Servidor Interno (Sideloading)

Para pruebas o entornos muy restringidos:

1. Debes empaquetar la extensión (crear el archivo .crx) y generar un archivo XML de actualización. Aloja ambos en un servidor web interno accesible por los equipos.
2. En la directiva de instalación forzada mencionada anteriormente, añade el ID de la extensión y la URL de tu servidor (ej. [ID_EXTENSION];https://mi-servidor-interno.local/extension_update.xml).

4.2. Plantilla de Políticas y Configuración (Managed Storage)

Una vez que la extensión se despliega, el administrador debe inyectar la configuración. En Chrome, esto se realiza mediante las políticas de extensiones de terceros (Managed Storage). Estas políticas (basadas en nuestro schema.json) aseguran que la extensión actúe de forma autónoma y bloquean cualquier modificación por parte del usuario final.

Los administradores pueden forzar la configuración de los siguientes campos en la plantilla:

• Dominios objetivo (customDomains): URLs donde la extensión estará activa. El administrador puede añadir o quitar dominios libremente (ej. chatgpt.com, claude.ai). También permite establecer restricciones de rutas específicas (ej. m365.cloud.microsoft/chat) para limitar la actuación solo a esas áreas y dejar el resto del dominio como excepción.
• SIEM Webhook (siemWebhookUrl): La URL del endpoint (Collector) donde se enviarán los logs.
• Formato de Log (logFormat): El estándar en el que el SIEM espera recibir los datos (CEF, LEEF, Syslog, CSV, JSON).
• Identificador de Usuario (endpointIdentifier): Nombre de usuario, email o hostname (ej. jdoe-laptop) para saber quién generó la alerta. La extensión también autogenera un UUID único por dispositivo (device_id) para trazabilidad.
• Clave de Cifrado (siemEncryptionKey): Contraseña o clave secreta utilizada para el cifrado AES-256-GCM del payload antes de enviarlo al SIEM.
• Bypass de Justificación (allowBypass): Permite a ciertos grupos de usuarios saltarse un bloqueo de DLP temporalmente (60 segundos) aportando una justificación escrita, la cual será auditada.
• Expresiones Regulares (customRegexes): Permite inyectar reglas de detección personalizadas (ej. números de expediente médico, formatos de facturas internos).

4.3. Implementación de las Políticas en el Dominio

Para distribuir esta configuración (la plantilla de políticas) a todos los equipos del dominio, el administrador tiene dos opciones principales:

Opción A: Preferencias de directiva de grupo (GPP - Recomendado)

La forma más estructurada de inyectar las configuraciones del schema.json es creando las claves de registro a través de las Preferencias de GPO:

1. En el GPMC, edita tu política y navega a Configuración del equipo > Preferencias > Configuración de Windows > Registro.
2. Crea un nuevo Elemento de Registro (Registry Item) para cada configuración que desees forzar (ej. siemWebhookUrl, customDomains, etc.).
3. La ruta de la clave base (Key Path) variará dependiendo del navegador:
   • Para Chrome: SOFTWARE\Policies\Google\Chrome\3rdparty\extensions\[ID_DE_LA_EXTENSION]\policy
   • Para Edge: SOFTWARE\Policies\Microsoft\Edge\3rdparty\extensions\[ID_DE_LA_EXTENSION]\policy
4. Selecciona el tipo de valor adecuado (REG_SZ para textos y JSONs, REG_DWORD para booleanos como allowBypass).

Opción B: Archivo de Registro Directo (.reg)

Alternativamente, puedes importar la configuración directamente al Registro de Windows en los equipos finales. Aquí tienes un ejemplo de la plantilla base (puedes incluir ambas rutas en el mismo archivo):

Windows Registry Editor Version 5.00

; Configuración para Google Chrome
[HKEY_LOCAL_MACHINE\Software\Policies\Google\Chrome\3rdparty\extensions\ID_DE_LA_EXTENSION\policy]
"customDomains"="[\"chatgpt.com\", \"claude.ai\", \"m365.cloud.microsoft/chat\"]"
"siemWebhookUrl"="https://siem.midominio.local:8088/services/collector"
"logFormat"="JSON"
"siemEncryptionKey"="M1_Cl4v3_S3cr3t4_S0C"
"allowBypass"=dword:00000001
"endpointIdentifier"="LAPTOP-%USERNAME%"
"customRegexes"="[{\"name\": \"Expediente Médico\", \"pattern\": \"EXP-\\\\d{6}\", \"active\": true}]"

; Configuración para Microsoft Edge
[HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Edge\3rdparty\extensions\ID_DE_LA_EXTENSION\policy]
"customDomains"="[\"chatgpt.com\", \"claude.ai\", \"m365.cloud.microsoft/chat\"]"
"siemWebhookUrl"="https://siem.midominio.local:8088/services/collector"
"logFormat"="JSON"
"siemEncryptionKey"="M1_Cl4v3_S3cr3t4_S0C"
"allowBypass"=dword:00000001
"endpointIdentifier"="LAPTOP-%USERNAME%"
"customRegexes"="[{\"name\": \"Expediente Médico\", \"pattern\": \"EXP-\\\\d{6}\", \"active\": true}]"

Opción C: Empresas sin Directorio Activo (Distribución Manual o MDM)

Si tu organización no cuenta con un dominio Active Directory (AD) y no dispones de políticas GPO centralizadas, puedes configurar la extensión de forma extremadamente sencilla mediante un script de registro (.reg). Este método es ideal para PyMEs o equipos desvinculados del dominio:

1. Abre el Bloc de Notas, copia el código del bloque superior (Opción B) y ajusta los valores a tus necesidades (tu URL del SIEM, clave secreta, dominios permitidos, etc.).
2. Guarda el archivo en tu escritorio con el nombre config_ai_shield.reg (asegúrate de que la extensión sea .reg y no .txt).
3. Distribuye este archivo a tus empleados (vía email, carpeta compartida, intranet o USB), o despliégalo mediante tu herramienta RMM/MDM (Intune, NinjaOne, etc.).
4. El empleado (o el script RMM) solo debe hacer doble clic sobre el archivo .reg y aceptar la advertencia de seguridad de Windows. La configuración se aplicará instantáneamente, la extensión quedará protegida sin que el usuario pueda modificarla desde el panel, y comenzará a enviar logs.

Panel de configuración manual para administradores.

5. Integración y Envío de Logs a SIEM

Notmining AI Shield está diseñado para integrarse de forma nativa con los principales SIEMs del mercado (Splunk, QRadar, ArcSight, Microsoft Sentinel, etc.). La integración se realiza mediante envíos HTTP/HTTPS directos desde el navegador del usuario al colector del SIEM, sin necesidad de servidores intermedios.

Pasos para la integración:

1. Habilitar un Colector HTTP en el SIEM: Configura tu SIEM para recibir eventos a través de HTTP/HTTPS. Por ejemplo, en Splunk habilita un HTTP Event Collector (HEC), o en QRadar un HTTP Receiver. Asegúrate de obtener la URL del endpoint y, si es necesario, el token de autenticación (que puedes incluir en la propia URL).
2. Configurar la Extensión vía GPO: En el archivo schema.json o en el panel de administrador, establece la política webhookUrl con la dirección de tu colector (ej. https://siem.midominio.local:8088/services/collector).
3. Seleccionar el Formato de Log: Configura la política logFormat según lo que espere tu SIEM (JSON, CEF, LEEF, Syslog o CSV).
4. Recepción de Datos: Cada vez que la extensión bloquee o audite un intento de filtración de datos, enviará automáticamente una petición POST a la URL configurada con el log formateado.

Formatos Soportados y Ejemplos de Payload

Dependiendo del formato elegido, el payload de la petición POST variará para adaptarse a los estándares de ingesta de tu SIEM. Aquí tienes un ejemplo de cómo se vería un evento de bloqueo por detectar un DNI en formato JSON:

{
  "timestamp": "2026-04-23T10:30:00Z",
  "action": "blocked",
  "url": "chatgpt.com",
  "matchedRule": "National ID (DNI/NIE/SSN)",
  "matchedContent": "[ENCRYPTED_PAYLOAD]",
  "userJustification": ""
}

Y el mismo evento estructurado en formato CEF (ArcSight):

CEF:0|Notmining|AI Shield|1.2.0|DLP_BLOCK|DLP Policy Violation|7|act=blocked request=chatgpt.com msg=National ID (DNI/NIE/SSN) cs1Label=EncryptedContent cs1={"encrypted":true,"algorithm":"AES-256-GCM","iv":"...","ciphertext":"..."}

Comprobación de la Conexión

Una vez configurada la URL del SIEM en el panel, debes activar el Lock Settings (Enterprise Mode) en la extensión. Si este modo no está activado, la extensión no enviará logs al exterior por motivos de privacidad. Para comprobar que el SIEM (o el script receptor) es alcanzable, puedes utilizar el botón Test Connection en el propio panel, que realizará un Healthcheck automático. Si el endpoint responde correctamente, verás un indicador verde de éxito (Connected).

Integración con Wazuh

Wazuh no dispone de un "Webhook HTTP Receiver" nativo abierto por defecto para ingestar logs arbitrarios (su API REST se utiliza principalmente para gestión y consulta, no para ingesta masiva de eventos sueltos). Además, no es factible que el agente lea la base de datos interna de Chrome (LevelDB) por las restricciones de bloqueo del proceso del navegador.

Por tanto, el método oficial soportado y recomendado en entornos Wazuh es desplegar un sencillo script en Python (o herramientas como Logstash/Fluentd) que actúe como servidor intermedio: recibirá el webhook HTTP en tiempo real de la extensión, descifrará el contenido (usando tu clave) y lo escribirá limpiamente en un fichero de texto local estándar (ej. /var/log/notmining_dlp.log) que el agente de Wazuh sí podrá ingerir sin problemas mediante <localfile>.

1. Script Receptor (Python):

from flask import Flask, request
import json
import logging
import base64
from datetime import datetime
import re
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
import os
from flask_cors import CORS
import logging

# Deshabilitar el logger por defecto de Flask (Werkzeug) para que no ensucie la consola/logs
log = logging.getLogger('werkzeug')
log.disabled = True

app = Flask(__name__)
CORS(app) # Allow Cross-Origin requests from the Chrome extension

LOG_FILE = '/var/log/notmining_dlp.log'

# Usamos un logger específico y nos aseguramos de que no hay handlers antiguos
logger = logging.getLogger('wazuh_logger')
logger.setLevel(logging.INFO)

# Evitar añadir múltiples handlers si el script se recarga
if not logger.handlers:
    file_handler = logging.FileHandler(LOG_FILE, mode='a')
    file_handler.setFormatter(logging.Formatter('%(message)s'))
    logger.addHandler(file_handler)

# Debe coincidir con la "siemEncryptionKey" configurada en GPO / Extensión
SHARED_SECRET = "MiSuperPassword123"

# Token para evitar inyección de logs falsos. Debe coincidir con "siemAuthHeader"
EXPECTED_AUTH_HEADER = "Bearer mi_token_secreto"

def decrypt_payload(encrypted_obj, password):
    try:
        kdf = PBKDF2HMAC(
            algorithm=hashes.SHA256(),
            length=32,
            salt=b'notmining_salt',
            iterations=100000,
        )
        key = kdf.derive(password.encode())
        aesgcm = AESGCM(key)
        
        iv = base64.b64decode(encrypted_obj['iv'])
        ciphertext = base64.b64decode(encrypted_obj['ciphertext'])
        
        decrypted_data = aesgcm.decrypt(iv, ciphertext, None)
        return decrypted_data.decode('utf-8')
    except Exception as e:
        return f"[DECRYPTION_FAILED] {str(e)}"

@app.route('/', methods=['GET'])
def health_check():
    return {"status": "Wazuh Webhook Receiver is running"}, 200

@app.route('/webhook', methods=['POST', 'OPTIONS'])
def siem_webhook():
    # Manejar las peticiones Preflight (CORS) de Chrome
    if request.method == 'OPTIONS':
        return '', 204

    # Verificar autenticación
    auth_header = request.headers.get('Authorization', '')
    if auth_header != EXPECTED_AUTH_HEADER:
        return {"error": "Unauthorized", "message": "Invalid token"}, 401

    # Soportar tanto JSON como texto plano (Syslog/CEF)
    data = request.json if request.is_json else request.get_data(as_text=True)
    
    # Si la extensión envió el payload cifrado
    if data and isinstance(data, dict) and data.get('encrypted'):
        decrypted_str = decrypt_payload(data, SHARED_SECRET)
        if decrypted_str.startswith("[DECRYPTION_FAILED]"):
            data = {"error": "Decryption failed.", "raw": decrypted_str}
        else:
            try:
                data = json.loads(decrypted_str)
            except json.JSONDecodeError:
                data = decrypted_str # Era Syslog cifrado
            
    # Forzar la hora del sistema en el log (Wazuh necesita la hora correcta para las alertas)
    current_sys_time = datetime.now().astimezone().isoformat()

    if isinstance(data, dict):
        if 'timestamp' in data:
            data['timestamp'] = current_sys_time
        logger.info(json.dumps(data))
    else:
        data = re.sub(r'\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?', current_sys_time, data, count=1)
        logger.info(data)
        
    return {"status": "success"}, 200

if __name__ == '__main__':
    # NOTA DE SEGURIDAD: Por defecto se escucha en 127.0.0.1 (localhost) para evitar exponer
    # el puerto en todas las interfaces de red, lo cual es inseguro.
    # Si necesitas recibir logs de otros equipos en la red, cambia esto a '0.0.0.0', pero
    # asegúrate de restringir el acceso al puerto 8088 usando un firewall (iptables/ufw).
    app.run(host='127.0.0.1', port=8088)

2. Configuración del Agente Wazuh (ossec.conf):

Añade el siguiente bloque a la configuración del agente que se está ejecutando en el mismo servidor que el script de Python:

<localfile>
  <log_format>json</log_format>
  <location>/var/log/notmining_dlp.log</location>
</localfile>

Cifrado End-to-End (E2E) y Redes Internas

La seguridad de los logs en tránsito es una prioridad:

• Cifrado E2E: El contenido interceptado (el texto que el usuario intentó enviar a la IA) viaja cifrado en el payload. Incluso si el tráfico es interceptado, el dato sensible real permanece ofuscado.
• Flexibilidad de Transporte: Aunque se recomienda encarecidamente el uso de HTTPS para el Webhook del SIEM, la extensión permite el uso de HTTP plano. Esto está diseñado específicamente para entornos corporativos donde el tráfico se enruta a través de una VPN interna o redes segmentadas de confianza, reduciendo la sobrecarga de gestión de certificados SSL en colectores internos sin comprometer la seguridad del dato (gracias al cifrado E2E del payload).

6. Auditoría de Bypass ("Justification Mode")

Cuando la política allowBypass está activa, los usuarios que sean bloqueados verán un botón de "Justificar envío" en la alerta principal.

El usuario puede solicitar una excepción temporal si su caso de uso es legítimo.

Si deciden utilizarlo, se les obligará a explicar por qué necesitan enviar el dato (ej. "Es un código fuente open-source").

Formulario donde el empleado redacta la justificación para el equipo de ciberseguridad.

Al confirmar, la extensión pausa el bloqueo durante 60 segundos. Inmediatamente, se envía un evento al SIEM con action: "bypassed" y el campo justification relleno, permitiendo al equipo del SOC auditar la acción a posteriori y detectar posibles abusos de confianza.