Insider Threats

¿Qué son las Insider Threats?

Las Insider Threats (Amenazas Internas) son riesgos de seguridad de la información originados por personas que tienen acceso autorizado a los sistemas, redes y datos de una organización: empleados actuales, ex-empleados, contratistas, proveedores, socios comerciales. A diferencia de los ataques externos, las amenazas internas explotan la confianza depositada en el insider y su conocimiento íntimo de los sistemas.

Desde mi experiencia como perito informático forense especializado en investigaciones laborales, el 60% de las brechas de datos en empresas tienen origen interno, según datos del Ponemon Institute 2025. He peritado casos que van desde el administrador de sistemas despechado que borró toda la infraestructura cloud, hasta el comercial que se llevó la base de datos de clientes a la competencia.

Tipología de Amenazas Internas

1. Insider Malicioso (Malicious Insider)

• Motivación: Lucro económico, venganza, ideología
• Acción: Robo deliberado de propiedad intelectual, sabotaje de sistemas, filtración de secretos comerciales
• Perfil típico: Empleado con acceso privilegiado próximo a abandonar la empresa

2. Insider Negligente (Negligent Insider)

• Motivación: Desconocimiento, descuido
• Acción: Clic en phishing, mal uso de credenciales, envío de datos a correos personales
• Perfil típico: Empleado sin formación en ciberseguridad

3. Insider Comprometido (Compromised Insider)

• Motivación: Coerción, chantaje
• Acción: Colaboración forzada con atacantes externos, acceso concedido bajo amenaza
• Perfil típico: Empleado con información comprometedora o presiones externas

Indicadores de Amenaza Interna (IoC)

Como perito forense, busco estos Indicators of Compromise en investigaciones laborales:

Indicadores Técnicos

# Consultas SQL para detectar comportamientos anómalos
# Base de datos de logs de actividad corporativa

-- 1. Accesos fuera de horario laboral
SELECT
    user_id,
    username,
    COUNT(*) as after_hours_logins,
    GROUP_CONCAT(DISTINCT DATE(login_timestamp)) as dates
FROM authentication_logs
WHERE HOUR(login_timestamp) NOT BETWEEN 8 AND 20  -- Fuera de 8-20h
    AND DAYOFWEEK(login_timestamp) NOT IN (1, 7)  -- No fin de semana
    AND login_timestamp > DATE_SUB(NOW(), INTERVAL 30 DAY)
GROUP BY user_id
HAVING after_hours_logins > 10
ORDER BY after_hours_logins DESC;

-- 2. Descarga masiva de archivos (exfiltración)
SELECT
    u.username,
    u.department,
    COUNT(fa.file_id) as files_downloaded,
    SUM(f.file_size_mb) as total_mb_downloaded,
    COUNT(DISTINCT DATE(fa.access_timestamp)) as days_active
FROM file_access_logs fa
JOIN users u ON fa.user_id = u.user_id
JOIN files f ON fa.file_id = f.file_id
WHERE fa.action = 'download'
    AND fa.access_timestamp > DATE_SUB(NOW(), INTERVAL 7 DAY)
GROUP BY u.user_id
HAVING files_downloaded > 500 OR total_mb_downloaded > 10000
ORDER BY total_mb_downloaded DESC;

-- 3. Acceso a recursos fuera del ámbito del puesto
SELECT
    u.username,
    u.job_title,
    r.resource_name,
    r.sensitivity_level,
    COUNT(*) as unauthorized_accesses
FROM access_logs al
JOIN users u ON al.user_id = u.user_id
JOIN resources r ON al.resource_id = r.resource_id
LEFT JOIN authorized_access aa
    ON al.user_id = aa.user_id AND al.resource_id = aa.resource_id
WHERE aa.authorization_id IS NULL  -- Sin autorización
    AND r.sensitivity_level IN ('CONFIDENTIAL', 'SECRET')
    AND al.access_timestamp > DATE_SUB(NOW(), INTERVAL 30 DAY)
GROUP BY u.user_id, r.resource_id
HAVING unauthorized_accesses > 3
ORDER BY unauthorized_accesses DESC;

-- 4. Uso de dispositivos USB no autorizados
SELECT
    u.username,
    d.device_type,
    d.device_serial,
    COUNT(*) as connection_events,
    SUM(dt.data_transferred_mb) as total_data_mb
FROM device_connections dc
JOIN users u ON dc.user_id = u.user_id
JOIN devices d ON dc.device_id = d.device_id
LEFT JOIN data_transfers dt ON dc.connection_id = dt.connection_id
WHERE d.device_type = 'USB_STORAGE'
    AND d.authorized = FALSE
    AND dc.connection_timestamp > DATE_SUB(NOW(), INTERVAL 14 DAY)
GROUP BY u.user_id, d.device_id
ORDER BY total_data_mb DESC;

-- 5. Búsquedas sospechosas en bases de datos
SELECT
    u.username,
    COUNT(*) as query_count,
    COUNT(DISTINCT q.table_name) as tables_accessed,
    GROUP_CONCAT(DISTINCT q.query_type) as query_types
FROM database_queries q
JOIN users u ON q.user_id = u.user_id
WHERE q.query_type IN ('SELECT *', 'DUMP', 'EXPORT')
    AND q.row_count > 10000  -- Consultas masivas
    AND q.execution_timestamp > DATE_SUB(NOW(), INTERVAL 7 DAY)
GROUP BY u.user_id
HAVING query_count > 50
ORDER BY query_count DESC;

Indicadores Conductuales

En peritajes laborales, también analizo patrones de comportamiento mediante entrevistas con RRHH y supervisores:

• Cambios en el comportamiento: Aislamiento repentino, evasión de conversaciones
• Señales de descontento: Quejas frecuentes sobre salario, reconocimiento, carga de trabajo
• Violaciones de políticas: Incumplimiento de normativas de seguridad, intentos de eludir controles
• Preparación para salida: Actualización de LinkedIn, entrevistas con competidores
• Acceso excesivo a información: Consulta de datos no relacionados con sus funciones

Investigación Forense de Insider Threats

Como perito informático, sigo esta metodología en investigaciones laborales:

Herramientas Forenses Especializadas

Adquisición de evidencias:

# Crear imagen forense completa del disco del empleado
# IMPORTANTE: Hacerlo ANTES de informar al empleado

# 1. Identificar dispositivo (ej. /dev/sda)
lsblk

# 2. Crear imagen forense con dd
sudo dd if=/dev/sda of=/mnt/forensic/employee_disk.img bs=4M status=progress

# 3. Calcular hash SHA-256 para cadena de custodia
sha256sum /mnt/forensic/employee_disk.img > employee_disk.img.sha256

# 4. Montar imagen en modo solo lectura
sudo losetup -r -f employee_disk.img
sudo mount -o ro /dev/loop0p1 /mnt/forensic_analysis

# 5. Extraer logs de sistema Windows
sudo cp -r /mnt/forensic_analysis/Windows/System32/winevt/Logs /mnt/evidence/windows_logs

Análisis de logs de Windows Event:

#!/usr/bin/env python3
"""
Script forense para analizar Windows Event Logs en busca de insider threats
Autor: Jonathan Izquierdo - Perito Informático Forense
"""

import Evtx.Evtx as evtx
import json
from datetime import datetime
from collections import defaultdict

def analyze_windows_event_log(evtx_file):
    """
    Analiza logs de Windows para detectar indicadores de insider threat

    Event IDs relevantes:
    - 4624: Logon exitoso
    - 4625: Logon fallido
    - 4720: Cuenta de usuario creada
    - 4738: Cuenta de usuario modificada
    - 4776: Intento de validación de credenciales
    - 5140: Acceso a recurso compartido de red
    """
    findings = defaultdict(list)

    with evtx.Evtx(evtx_file) as log:
        for record in log.records():
            event_id = record.event_id()
            timestamp = record.timestamp()
            xml = record.xml()

            # Detectar logons fuera de horario
            if event_id == 4624:  # Logon exitoso
                hour = timestamp.hour
                if hour < 7 or hour > 21:  # Fuera de 7-21h
                    findings['after_hours_logon'].append({
                        'timestamp': timestamp.isoformat(),
                        'event_id': event_id,
                        'details': parse_logon_event(xml)
                    })

            # Detectar accesos a recursos compartidos sospechosos
            elif event_id == 5140:  # Network share access
                share_name = extract_share_name(xml)
                if share_name in ['\\\\fileserver\\HR', '\\\\fileserver\\Finance', '\\\\fileserver\\R&D']:
                    findings['sensitive_share_access'].append({
                        'timestamp': timestamp.isoformat(),
                        'share': share_name,
                        'details': parse_share_access(xml)
                    })

            # Detectar intentos de escalada de privilegios
            elif event_id == 4738:  # User account modified
                if 'Admin' in xml:
                    findings['privilege_escalation_attempt'].append({
                        'timestamp': timestamp.isoformat(),
                        'details': parse_account_modification(xml)
                    })

    return findings

def analyze_usb_connections(evtx_file):
    """
    Analiza conexiones de dispositivos USB (potential data exfiltration)

    Event IDs:
    - 20001: PnP device connected
    - 20003: PnP device removed
    """
    usb_devices = []

    with evtx.Evtx(evtx_file) as log:
        for record in log.records():
            if record.event_id() in [20001, 20003]:
                device_info = parse_usb_event(record.xml())

                if device_info.get('device_type') == 'USB_STORAGE':
                    usb_devices.append({
                        'timestamp': record.timestamp().isoformat(),
                        'event': 'connected' if record.event_id() == 20001 else 'disconnected',
                        'device_serial': device_info.get('serial_number'),
                        'vendor': device_info.get('vendor'),
                        'capacity_gb': device_info.get('capacity_gb')
                    })

    return usb_devices

def generate_forensic_timeline(findings, usb_devices, output_file='timeline.json'):
    """
    Genera timeline forense combinando todos los eventos
    """
    timeline = []

    # Añadir hallazgos de Event Log
    for category, events in findings.items():
        for event in events:
            timeline.append({
                'timestamp': event['timestamp'],
                'category': category,
                'severity': 'HIGH' if 'privilege' in category else 'MEDIUM',
                'details': event.get('details', {})
            })

    # Añadir eventos de USB
    for usb_event in usb_devices:
        timeline.append({
            'timestamp': usb_event['timestamp'],
            'category': 'usb_device',
            'severity': 'HIGH',
            'details': usb_event
        })

    # Ordenar por timestamp
    timeline.sort(key=lambda x: x['timestamp'])

    # Guardar timeline
    with open(output_file, 'w', encoding='utf-8') as f:
        json.dump(timeline, f, indent=2, ensure_ascii=False)

    print(f"[+] Timeline forense generado: {output_file}")
    print(f"[+] Total de eventos: {len(timeline)}")

# Uso en investigación forense
if __name__ == "__main__":
    security_log = '/mnt/evidence/windows_logs/Security.evtx'
    system_log = '/mnt/evidence/windows_logs/System.evtx'

    findings = analyze_windows_event_log(security_log)
    usb_devices = analyze_usb_connections(system_log)

    generate_forensic_timeline(findings, usb_devices)

Análisis de correo electrónico (PST de Outlook):

import pypff  # Python bindings para libpff (PST file format)

def analyze_outlook_pst(pst_file, keywords=['confidencial', 'secreto', 'competencia']):
    """
    Analiza archivo PST de Outlook en busca de evidencias de exfiltración

    Args:
        pst_file: Ruta al archivo .pst
        keywords: Palabras clave sospechosas a buscar
    """
    pst = pypff.file()
    pst.open(pst_file)

    root = pst.get_root_folder()

    suspicious_emails = []

    def scan_folder(folder):
        for i in range(folder.get_number_of_sub_messages()):
            message = folder.get_sub_message(i)

            subject = message.get_subject()
            body = message.get_plain_text_body()
            sender = message.get_sender_name()
            recipients = message.get_recipients()
            timestamp = message.get_client_submit_time()

            # Detectar envíos a correos personales
            personal_domains = ['gmail.com', 'hotmail.com', 'yahoo.com', 'outlook.com']
            is_personal_recipient = any(
                any(domain in recipient for domain in personal_domains)
                for recipient in recipients
            )

            # Detectar archivos adjuntos
            has_attachments = message.get_number_of_attachments() > 0

            # Buscar keywords sospechosas
            contains_keywords = any(
                keyword.lower() in (subject + body).lower()
                for keyword in keywords
            )

            if (is_personal_recipient and has_attachments) or contains_keywords:
                suspicious_emails.append({
                    'timestamp': timestamp,
                    'subject': subject,
                    'sender': sender,
                    'recipients': recipients,
                    'attachments': [
                        message.get_attachment(j).get_name()
                        for j in range(message.get_number_of_attachments())
                    ],
                    'reason': 'personal_recipient' if is_personal_recipient else 'contains_keywords'
                })

        # Recursión para subcarpetas
        for j in range(folder.get_number_of_sub_folders()):
            scan_folder(folder.get_sub_folder(j))

    scan_folder(root)

    return suspicious_emails

Casos Prácticos Reales

Caso 1: Administrador de Sistemas que Borró Infraestructura AWS

Situación: Una startup tecnológica despidió a su administrador de sistemas. 48 horas después, toda su infraestructura AWS fue borrada: instancias EC2 terminadas, buckets S3 vaciados, bases de datos RDS destruidas.

Investigación forense:

# Análisis de CloudTrail logs (AWS audit trail)
aws cloudtrail lookup-events \
    --lookup-attributes AttributeKey=Username,AttributeValue=admin_despedido \
    --start-time 2025-10-15T00:00:00Z \
    --end-time 2025-10-17T23:59:59Z \
    --max-results 1000 \
    --query 'Events[?EventName==`TerminateInstances` || EventName==`DeleteBucket` || EventName==`DeleteDBInstance`]'

Evidencias encontradas:

• Timestamp del ataque: 16 octubre 2025, 03:47 AM (2 días post-despido)
• IP de origen: Dirección residencial del ex-empleado (verificada con ISP)
• Credenciales usadas: Access Key del ex-admin (no revocada tras despido)
• Acciones ejecutadas: 47 instancias EC2 terminadas, 12 buckets S3 borrados, 3 bases de datos RDS destruidas
• Daño estimado: €340.000 (pérdida de datos + reconstrucción de infraestructura)

Resultado: Denuncia penal por daños informáticos (CP art. 264.2). Sentencia condenatoria con 2 años de prisión y compensación de €340.000. Mi informe pericial fue clave para demostrar intencionalidad y cuantificar daños.

Caso 2: Comercial que Exfiltró Base de Datos de Clientes

Situación: Un comercial de empresa de software B2B renunció para unirse a la competencia. Dos semanas después, la competencia contactó a todos los clientes del comercial con ofertas personalizadas.

Investigación pericial:

-- Análisis de base de datos: ¿El comercial hizo dumps antes de irse?
SELECT
    query_text,
    execution_timestamp,
    rows_returned,
    user_account
FROM database_audit_log
WHERE user_account = 'comercial_renunciado'
    AND execution_timestamp BETWEEN '2025-09-01' AND '2025-09-15'  -- 2 semanas pre-renuncia
    AND query_text LIKE '%SELECT%FROM clients%'
ORDER BY execution_timestamp DESC;

Evidencias documentadas:

1. Consulta SQL masiva: 12 sept 2025, 19:34h - SELECT * FROM clients WHERE assigned_to = 'comercial_renunciado' (retornó 1.247 registros)
2. Correo a cuenta personal: 12 sept 2025, 19:41h - Envío de archivo clientes.xlsx (3.2 MB) a su Gmail personal
3. Descarga en dispositivo personal: Análisis forense del portátil personal del comercial (entregado voluntariamente por orden judicial) reveló el archivo clientes.xlsx con timestamp coincidente
4. Uso por competidor: La competencia admitió haber recibido “información de mercado” del nuevo empleado

Resultado: Despido procedente ratificado por juzgado de lo social. Demanda civil contra el comercial y la empresa competidora por violación de secretos empresariales (Ley 1/2019). Acuerdo extrajudicial de €180.000.

Caso 3: Insider Negligente - Phishing con Ransomware

Situación: Un empleado del departamento de contabilidad recibió un correo de phishing simulando ser de su banco. Al introducir credenciales en el sitio falso, los atacantes obtuvieron acceso VPN a la red corporativa, desplegando ransomware.

Análisis forense:

• Vector inicial: Correo de phishing el 3 nov 2025, 10:23h
• Clic en link malicioso: 3 nov 2025, 10:24h (1 minuto después)
• Entrada de credenciales: 3 nov 2025, 10:25h
• Acceso VPN desde IP rusa: 3 nov 2025, 11:03h (con credenciales del empleado)
• Despliegue de ransomware: 3 nov 2025, 11:47h (cifrados 340 GB de datos)

Resultado: No se sancionó al empleado (negligencia no intencionada). Se implementó formación obligatoria en ciberseguridad y autenticación multifactor (MFA). Coste total del incidente: €520.000 (rescate + consultoría forense + pérdida operativa).

Marco Legal en España

Ámbito Laboral

Estatuto de los Trabajadores (Real Decreto Legislativo 2/2015)

Art. 20.3: Vigilancia y control del empresario

“El empresario podrá adoptar las medidas que estime más oportunas de vigilancia y control para verificar el cumplimiento por el trabajador de sus obligaciones y deberes laborales, guardando en su adopción y aplicación la consideración debida a su dignidad y teniendo en cuenta, en su caso, la capacidad real de los trabajadores con discapacidad.”

Art. 54: Despido disciplinario

Causas de despido procedente:

• Art. 54.2.d): “La transgresión de la buena fe contractual, así como el abuso de confianza en el desempeño del trabajo”
• Art. 54.2.g): “El acoso por razón de origen racial o étnico, religión o convicciones, discapacidad, edad u orientación sexual y el acoso sexual o por razón de sexo al empresario o a las personas que trabajan en la empresa”

Protección de Datos (RGPD)

Art. 88 RGPD: Tratamiento en el contexto laboral

• Permite monitorización de empleados con garantías adecuadas:
  • Información previa y transparente
  • Finalidad específica y legítima
  • Proporcionalidad
  • Limitación en el tiempo

Jurisprudencia clave:

STC 241/2012: El Tribunal Constitucional avaló la monitorización de correos electrónicos corporativos si:

1. Existe política de uso aceptable notificada al empleado
2. La monitorización es proporcional al objetivo (prevenir insider threats)
3. Se respeta el contenido esencial del derecho a la intimidad

STS 170/2013: Validez de despido disciplinario basado en evidencias de monitorización de sistemas informáticos corporativos.

Ámbito Penal

Código Penal - Delitos aplicables:

Art. 197: Descubrimiento y revelación de secretos

• Pena: 1-4 años prisión + multa

Art. 264: Daños informáticos

• Pena: 6 meses - 3 años prisión (art. 264.2 si daños graves)

Art. 278: Violación de secretos de empresa

• Pena: 2-4 años prisión + multa + inhabilitación especial

Prevención y Defensa contra Insider Threats

Medidas Técnicas

Medidas Organizativas

• Política de uso aceptable (AUP): Documento firmado por empleados describiendo usos permitidos de sistemas
• Formación en concienciación: Programas regulares sobre riesgos de insider threats
• Entrevistas de salida estructuradas: Identificar señales de descontento antes de que escale
• Cultura de seguridad: Fomentar el reporte de comportamientos sospechosos sin represalias

Soluciones DLP - Ejemplo de Configuración

# Configuración de política DLP (Microsoft Purview)
PolicyName: "Prevención de Exfiltración de Datos Sensibles"
Enabled: true

Rules:
  - Name: "Bloquear envío masivo de archivos a correos personales"
    Conditions:
      - EmailRecipient: external_personal  # gmail.com, hotmail.com, etc.
      - AttachmentCount: > 5
      - AttachmentTotalSize: > 10 MB
    Actions:
      - Block: true
      - Alert: [email protected]
      - Quarantine: true

  - Name: "Detectar consultas SQL masivas"
    Conditions:
      - DatabaseQueryType: SELECT
      - RowsReturned: > 10000
      - UserDepartment: not_in [IT, Analytics]
    Actions:
      - Alert: [email protected], [email protected]
      - RequireJustification: true

  - Name: "Controlar descarga de archivos marcados como confidenciales"
    Conditions:
      - FileLabel: CONFIDENTIAL
      - Action: download
      - Location: not_in [corporate_network]
    Actions:
      - Block: true
      - Alert: [email protected]
      - Log: detailed

  - Name: "Monitorizar uso de dispositivos USB"
    Conditions:
      - DeviceType: USB_STORAGE
      - Authorized: false
    Actions:
      - Block: true
      - Alert: [email protected]
      - GenerateIncident: true

Relación con Otros Conceptos

• API Scraping: Insiders pueden usar técnicas de API scraping para exfiltrar datos masivos
• Cadena de Custodia: Fundamental en investigaciones de insider threats para admisibilidad judicial
• IDOR: Insiders pueden explotar vulnerabilidades IDOR para acceder a datos no autorizados

Conclusión

Las Insider Threats representan uno de los riesgos más complejos en ciberseguridad porque combinan acceso legítimo con intenciones maliciosas. Como perito informático forense especializado en investigaciones laborales, he aprendido que:

1. La prevención es más efectiva que la detección: Invertir en controles técnicos (DLP, UBA) y organizativos (formación, cultura)
2. La evidencia digital debe preservarse meticulosamente: Una cadena de custodia impecable es la diferencia entre ganar o perder en juicio
3. El equilibrio legal es delicado: Monitorizar empleados es legal, pero debe hacerse con transparencia, proporcionalidad y respeto a derechos fundamentales

Si sospechas de un insider threat en tu organización o necesitas un peritaje forense para un procedimiento de despido disciplinario, puedo ayudarte a investigar el incidente, preservar evidencias y elaborar un informe pericial sólido para defender tus intereses en sede judicial o laboral.

Última actualización: 4 de febrero de 2026 Categoría: Seguridad Código: SEC-011

Autor: Jonathan Izquierdo, Perito Informático Forense en Jaén Contacto: digitalperito.es