Automatizar Auditorías de Ciberseguridad OT

Aprende a automatizar auditorías de ciberseguridad en entornos OT con Python y n8n. Scripts, workflows y checklist para cumplir NIS2 e IEC 62443.

TodoAutomatizado 8 de julio de 2026 17 min de lectura

La primera vez que hice una auditoría de ciberseguridad OT fue en una planta química. Llegué con un portátil, Nmap y muchas ganas. A las dos horas, el responsable de producción me llamó por el walkie: “¿Qué has hecho? Se ha parado la línea 3”. Un escaneo de puertos había tumbado un PLC Modicon de los 90 que no soportaba tráfico inesperado.

Aprendí tres cosas ese día: que auditar entornos OT no es como auditar IT, que los equipos industriales son frágiles ante herramientas agresivas, y que necesitas un proceso repetible y controlado. Hoy, después de años auditando plantas, tengo ese proceso automatizado con Python y n8n, y voy a compartirlo contigo.

Automatizar auditorías de ciberseguridad OT no es un lujo: con NIS2 llamando a la puerta y ataques como los de Colonial Pipeline o Norsk Hydro frescos en la memoria, es una obligación para cualquier planta que quiera operar tranquila.

Por Qué Necesitas Automatizar las Auditorías OT

Una auditoría de ciberseguridad OT típica implica:

Inventariar todos los activos de la red industrial (PLCs, HMIs, switches, gateways).
Verificar la segmentación de red entre IT y OT.
Comprobar versiones de firmware y parches pendientes.
Revisar cuentas de usuario y políticas de acceso.
Analizar reglas de firewall entre zonas.
Verificar la existencia de backups actualizados.
Documentar todo en un informe.

Hacerlo manualmente una vez puede llevar 2-3 semanas. Y luego tienes que repetirlo cada trimestre o cada vez que cambias algo en la red. Con NIS2 exigiendo evidencias continuas de gestión de riesgos, la auditoría manual no escala.

La automatización te da:

Consistencia: el script no se olvida de comprobar un switch remoto.
Velocidad: lo que tarda 3 semanas a mano se hace en horas.
Trazabilidad: cada ejecución genera un informe con timestamp que sirve como evidencia.
Continuidad: puedes programar auditorías parciales semanales sin esfuerzo humano.

Checklist de Auditoría OT: Los 12 Puntos Clave

Antes de automatizar, necesitas saber qué comprobar. Este checklist está basado en IEC 62443 y en la experiencia del sector práctica:

Inventario de activos: ¿Tenemos una lista actualizada de todos los dispositivos en la red OT?
Segmentación de red: ¿Existe un firewall entre IT y OT? ¿Las zonas y conductos están definidos según IEC 62443?
Control de acceso: ¿Los PLCs y HMIs tienen contraseñas cambiadas respecto a las de fábrica?
Gestión de cuentas: ¿Quién tiene acceso remoto a la red OT? ¿Hay cuentas compartidas?
Parches y firmware: ¿Los equipos tienen el último firmware estable? ¿Hay vulnerabilidades conocidas (CVE)?
Backups: ¿Existen backups recientes de programas PLC, configuraciones de switches y HMIs?
Registros y logs: ¿Se registran los accesos y cambios en los equipos OT?
Acceso remoto: ¿El acceso remoto usa VPN con MFA? ¿Se audita quién accede y cuándo?
Comunicaciones: ¿Se usan protocolos seguros (OPC UA con certificados, MQTT con TLS)?
Respuesta a incidentes: ¿Existe un plan documentado? ¿Se ha probado?
Formación: ¿El personal de OT ha recibido formación en ciberseguridad?
Documentación: ¿Los diagramas de red están actualizados? ¿La documentación refleja la realidad?

Cada punto puede tener estado: ✅ Cumple, ⚠️ Parcial, ❌ No cumple, ℹ️ No aplica.

Descubrimiento de Activos OT con Python: El Enfoque Seguro

El inventario de activos es el primer paso de cualquier auditoría. Pero como aprendí por las malas, no puedes lanzar un Nmap agresivo contra una red OT. Necesitas un enfoque pasivo o semi-pasivo.

Opción 1: Descubrimiento pasivo con análisis de tráfico

"""
asset_discovery_passive.py
Descubrimiento pasivo de activos OT mediante captura de tráfico.
Requiere: scapy, ejecutar con permisos de captura.
"""

from scapy.all import sniff, IP, TCP, UDP
from collections import defaultdict
import json
from datetime import datetime

assets = defaultdict(lambda: {
    "first_seen": None,
    "last_seen": None,
    "protocols": set(),
    "ports": set(),
    "connections": set()
})

KNOWN_OT_PORTS = {
    502: "Modbus TCP",
    44818: "EtherNet/IP",
    4840: "OPC UA",
    20000: "DNP3",
    102: "S7comm (Siemens)",
    1883: "MQTT",
    8883: "MQTT TLS"
}

def analyze_packet(pkt):
    if IP in pkt:
        src = pkt[IP].src
        dst = pkt[IP].dst
        now = datetime.utcnow().isoformat()
        
        for ip in [src, dst]:
            if assets[ip]["first_seen"] is None:
                assets[ip]["first_seen"] = now
            assets[ip]["last_seen"] = now
        
        assets[src]["connections"].add(dst)
        
        if TCP in pkt:
            port = pkt[TCP].dport
            assets[dst]["ports"].add(port)
            if port in KNOWN_OT_PORTS:
                assets[dst]["protocols"].add(KNOWN_OT_PORTS[port])
        
        elif UDP in pkt:
            port = pkt[UDP].dport
            assets[dst]["ports"].add(port)

def save_report():
    report = {}
    for ip, data in assets.items():
        report[ip] = {
            "first_seen": data["first_seen"],
            "last_seen": data["last_seen"],
            "protocols": list(data["protocols"]),
            "ports": sorted(list(data["ports"])),
            "connections": list(data["connections"])
        }
    
    filename = f"ot_assets_{datetime.now().strftime('%Y%m%d_%H%M')}.json"
    with open(filename, "w") as f:
        json.dump(report, f, indent=2)
    print(f"Informe guardado: {filename}")
    print(f"Activos descubiertos: {len(report)}")

# Captura durante 10 minutos en la interfaz de red OT
print("Iniciando captura pasiva (10 min)...")
print("No genera tráfico — seguro para entornos OT")
try:
    sniff(iface="eth1", timeout=600, prn=analyze_packet, store=0)
except KeyboardInterrupt:
    pass
finally:
    save_report()

Este script simplemente escucha el tráfico existente sin inyectar paquetes. Es seguro para cualquier entorno OT. La desventaja es que solo descubre equipos que están comunicando activamente.

Opción 2: Escaneo activo controlado

Para un inventario más completo, puedes hacer escaneos activos pero con precauciones:

"""
asset_discovery_active.py
Escaneo activo CONTROLADO de red OT.
⚠️ Usar solo en ventanas de mantenimiento acordadas.
"""

import nmap
import json
from datetime import datetime

# IMPORTANTE: solo escanear puertos OT conocidos, sin detección de SO
# Los escaneos agresivos pueden tumbar PLCs antiguos
OT_PORTS = "102,502,4840,44818,1883,8883,20000,80,443,22"

scanner = nmap.PortScanner()

def safe_ot_scan(network: str) -> dict:
    """Escaneo seguro para redes OT.
    
    Usa:
    - Ping scan para descubrimiento (sin escaneo de puertos invasivo)
    - Solo puertos OT conocidos
    - Sin detección de SO (-O puede tumbar equipos legacy)
    - Rate limiting para no saturar la red
    """
    print(f"Escaneando {network} — modo seguro OT")
    
    # Fase 1: Ping sweep (ARP en red local = seguro)
    scanner.scan(hosts=network, arguments='-sn')
    hosts_up = [h for h in scanner.all_hosts() if scanner[h].state() == 'up']
    print(f"Hosts activos: {len(hosts_up)}")
    
    # Fase 2: Escaneo de puertos OT con rate limiting
    results = {}
    for host in hosts_up:
        scanner.scan(
            hosts=host,
            ports=OT_PORTS,
            arguments='-sT --max-rate 100 --max-retries 1'
        )
        
        open_ports = []
        if host in scanner.all_hosts():
            for proto in scanner[host].all_protocols():
                for port in scanner[host][proto].keys():
                    state = scanner[host][proto][port]['state']
                    if state == 'open':
                        open_ports.append({
                            "port": port,
                            "state": state,
                            "service": scanner[host][proto][port].get('name', 'unknown')
                        })
        
        results[host] = {
            "hostname": scanner[host].hostname() if host in scanner.all_hosts() else "",
            "open_ports": open_ports,
            "scan_time": datetime.utcnow().isoformat()
        }
    
    return results

# Ejecutar
network = "192.168.10.0/24"  # Red OT — ajustar a tu rango
results = safe_ot_scan(network)

# Guardar
filename = f"ot_scan_{datetime.now().strftime('%Y%m%d_%H%M')}.json"
with open(filename, "w") as f:
    json.dump(results, f, indent=2)
print(f"Resultados guardados en {filename}")

Regla de oro: el escaneo activo solo en ventanas de mantenimiento acordadas con producción. Nunca en horario productivo. Y siempre con rate limiting.

Verificación Automática de Segmentación de Red

La segmentación entre IT y OT es probablemente el control más importante. Este script verifica que no haya rutas no autorizadas:

"""
check_segmentation.py
Verifica que la segmentación IT/OT está correcta.
"""

import subprocess
import json

# Definir zonas según tu arquitectura
ZONES = {
    "IT": ["10.0.0.0/16"],
    "OT_Control": ["192.168.10.0/24"],
    "OT_Supervision": ["192.168.20.0/24"],
    "DMZ_Industrial": ["172.16.0.0/24"]
}

# Reglas: desde qué zona se puede llegar a cuál
# True = permitido, False = debe estar bloqueado
ALLOWED_FLOWS = {
    ("IT", "OT_Control"): False,           # IT NO debe llegar a control
    ("IT", "DMZ_Industrial"): True,         # IT puede llegar a DMZ
    ("DMZ_Industrial", "OT_Supervision"): True,  # DMZ a supervisión OK
    ("DMZ_Industrial", "OT_Control"): False,     # DMZ NO a control
    ("OT_Supervision", "OT_Control"): True,      # Supervisión a control OK
}

def test_connectivity(src_ip: str, dst_ip: str, port: int = 80) -> bool:
    """Prueba conectividad TCP entre dos IPs."""
    try:
        result = subprocess.run(
            ["timeout", "3", "bash", "-c", 
             f"echo >/dev/tcp/{dst_ip}/{port}"],
            capture_output=True, timeout=5
        )
        return result.returncode == 0
    except (subprocess.TimeoutExpired, Exception):
        return False

def audit_segmentation() -> list:
    """Audita la segmentación verificando que las reglas se cumplen."""
    findings = []
    
    for (src_zone, dst_zone), should_allow in ALLOWED_FLOWS.items():
        # Tomar una IP representativa de cada zona
        src_net = ZONES[src_zone][0]
        dst_net = ZONES[dst_zone][0]
        
        # En una implementación real, probar con IPs específicas conocidas
        finding = {
            "test": f"{src_zone} -> {dst_zone}",
            "expected": "ALLOW" if should_allow else "BLOCK",
            "src_network": src_net,
            "dst_network": dst_net,
            "status": "PENDING"  # Se rellena con test real
        }
        findings.append(finding)
    
    return findings

results = audit_segmentation()
for r in results:
    status_icon = "⚠️" if r["status"] == "PENDING" else "✅"
    print(f"{status_icon} {r['test']}: esperado {r['expected']}")

Automatizar el Flujo Completo con n8n

Aquí es donde n8n brilla. Puedes crear un workflow que orqueste toda la auditoría:

Workflow de auditoría OT en n8n

┌──────────┐    ┌──────────────┐    ┌──────────────┐
│  Trigger │───▶│ Ejecutar     │───▶│ Analizar     │
│  (Cron   │    │ scripts      │    │ resultados   │
│  semanal)│    │ Python (SSH) │    │ (Code node)  │
└──────────┘    └──────────────┘    └──────┬───────┘
                                          │
                                   ┌──────▼───────┐
                                   │  Generar     │
                                   │  informe     │
                                   │  (HTML/PDF)  │
                                   └──────┬───────┘
                                          │
                              ┌───────────┼───────────┐
                              │           │           │
                        ┌─────▼─────┐ ┌───▼───┐ ┌────▼────┐
                        │ Guardar   │ │ Email │ │ Slack/  │
                        │ en drive  │ │       │ │ Teams   │
                        └───────────┘ └───────┘ └─────────┘

Configuración paso a paso

1. Trigger programado (Cron) Configura un nodo Schedule Trigger para ejecutar cada lunes a las 6:00 AM (antes del turno de mañana):

{
  "rule": {
    "interval": [{"field": "cronExpression", "expression": "0 6 * * 1"}]
  }
}

2. Ejecutar scripts de descubrimiento (SSH node) Usa el nodo SSH de n8n para conectar al servidor de auditoría que tiene visibilidad de la red OT:

cd /opt/ot-audit/scripts
python3 asset_discovery_passive.py --duration 300 --output /tmp/audit_assets.json
python3 check_segmentation.py --output /tmp/audit_segmentation.json
python3 check_firmware_versions.py --output /tmp/audit_firmware.json

3. Analizar resultados (Code node) Un nodo de código JavaScript en n8n que procesa los JSON y genera findings:

const assets = JSON.parse($input.first().json.assets);
const segmentation = JSON.parse($input.first().json.segmentation);

const findings = [];
let criticalCount = 0;
let warningCount = 0;

// Verificar activos nuevos no catalogados
const knownAssets = ['192.168.10.1', '192.168.10.10', /* ... */];
for (const [ip, data] of Object.entries(assets)) {
  if (!knownAssets.includes(ip)) {
    findings.push({
      severity: 'HIGH',
      category: 'Inventario',
      description: `Activo desconocido detectado: ${ip}`,
      protocols: data.protocols,
      recommendation: 'Identificar y catalogar o aislar'
    });
    criticalCount++;
  }
}

// Verificar puertos OT expuestos sin cifrar
for (const [ip, data] of Object.entries(assets)) {
  if (data.ports.includes(502)) {  // Modbus sin auth
    findings.push({
      severity: 'MEDIUM',
      category: 'Protocolos',
      description: `${ip}: Modbus TCP (502) expuesto — sin autenticación`,
      recommendation: 'Restringir acceso por firewall a IPs autorizadas'
    });
    warningCount++;
  }
}

return [{
  json: {
    date: new Date().toISOString(),
    total_assets: Object.keys(assets).length,
    critical: criticalCount,
    warnings: warningCount,
    findings: findings
  }
}];

4. Generar informe HTML Un nodo Code que genera el informe formateado:

const data = $input.first().json;
const html = `
<html>
<head><style>
  body { font-family: Arial; margin: 40px; }
  .critical { color: #d32f2f; }
  .warning { color: #f57c00; }
  .ok { color: #388e3c; }
  table { border-collapse: collapse; width: 100%; }
  th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
  th { background: #1a237e; color: white; }
</style></head>
<body>
  <h1>Informe de Auditoría de Ciberseguridad OT</h1>
  <p>Fecha: ${data.date}</p>
  <h2>Resumen</h2>
  <ul>
    <li>Activos detectados: ${data.total_assets}</li>
    <li class="critical">Hallazgos críticos: ${data.critical}</li>
    <li class="warning">Advertencias: ${data.warnings}</li>
  </ul>
  <h2>Hallazgos</h2>
  <table>
    <tr><th>Severidad</th><th>Categoría</th><th>Descripción</th><th>Recomendación</th></tr>
    ${data.findings.map(f => `
      <tr>
        <td class="${f.severity === 'HIGH' ? 'critical' : 'warning'}">${f.severity}</td>
        <td>${f.category}</td>
        <td>${f.description}</td>
        <td>${f.recommendation}</td>
      </tr>
    `).join('')}
  </table>
</body>
</html>`;

return [{ json: { html, subject: `Auditoría OT - ${data.critical} críticos, ${data.warnings} advertencias` } }];

5. Enviar por email y guardar Nodos estándar de n8n para enviar el informe y archivar una copia.

Si no has usado n8n antes, tengo una guía de primeros pasos que te ayudará a montarlo.

Verificación de Firmware y CVEs con Python

Uno de los checks más valiosos: comparar las versiones de firmware de tus equipos OT contra las vulnerabilidades conocidas:

"""
check_firmware_cves.py
Consulta CVEs para firmware de equipos OT.
Usa la API de NIST NVD (gratuita, requiere API key para más de 5 req/30s).
"""

import requests
import json
from time import sleep

# Inventario de equipos y firmware (mantener actualizado)
EQUIPMENT = [
    {"vendor": "Siemens", "product": "SIMATIC S7-1500", "version": "2.9.4"},
    {"vendor": "Siemens", "product": "SIMATIC HMI Comfort", "version": "17.0"},
    {"vendor": "Schneider Electric", "product": "Modicon M340", "version": "3.20"},
    {"vendor": "Moxa", "product": "EDS-408A", "version": "3.10"},
]

NVD_API = "https://services.nvd.nist.gov/rest/json/cves/2.0"

def search_cves(vendor: str, product: str) -> list:
    """Busca CVEs para un producto específico."""
    params = {
        "keywordSearch": f"{vendor} {product}",
        "resultsPerPage": 10
    }
    
    try:
        resp = requests.get(NVD_API, params=params, timeout=30)
        if resp.status_code == 200:
            data = resp.json()
            cves = []
            for item in data.get("vulnerabilities", []):
                cve = item.get("cve", {})
                cves.append({
                    "id": cve.get("id"),
                    "description": cve.get("descriptions", [{}])[0].get("value", ""),
                    "severity": cve.get("metrics", {}).get("cvssMetricV31", [{}])[0]
                              .get("cvssData", {}).get("baseSeverity", "UNKNOWN")
                              if cve.get("metrics", {}).get("cvssMetricV31") else "UNKNOWN"
                })
            return cves
        else:
            print(f"Error NVD API: {resp.status_code}")
            return []
    except Exception as e:
        print(f"Error consultando NVD: {e}")
        return []

# Ejecutar
all_findings = []
for equip in EQUIPMENT:
    print(f"Buscando CVEs para {equip['vendor']} {equip['product']}...")
    cves = search_cves(equip["vendor"], equip["product"])
    
    critical_cves = [c for c in cves if c["severity"] in ["CRITICAL", "HIGH"]]
    
    all_findings.append({
        "equipment": f"{equip['vendor']} {equip['product']}",
        "firmware": equip["version"],
        "total_cves": len(cves),
        "critical_high": len(critical_cves),
        "cves": critical_cves[:5]  # Top 5 críticos
    })
    
    sleep(6)  # Respetar rate limit de NVD

# Informe
with open("firmware_cve_report.json", "w") as f:
    json.dump(all_findings, f, indent=2)

for f in all_findings:
    status = "🔴" if f["critical_high"] > 0 else "🟢"
    print(f"{status} {f['equipment']} (v{f['firmware']}): "
          f"{f['critical_high']} CVEs críticos/altos de {f['total_cves']} totales")

Generación Automática de Informes de Cumplimiento

El informe final debe mapear tus hallazgos contra el framework de cumplimiento relevante. Con Python puedes generar informes PDF profesionales:

"""
generate_audit_report.py
Genera un informe PDF de auditoría OT.
Requiere: reportlab
"""

from reportlab.lib import colors
from reportlab.lib.pagesizes import A4
from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer
from reportlab.lib.styles import getSampleStyleSheet
from datetime import datetime

def generate_report(findings: list, output: str = "audit_report.pdf"):
    doc = SimpleDocTemplate(output, pagesize=A4)
    styles = getSampleStyleSheet()
    elements = []
    
    # Título
    elements.append(Paragraph(
        "Informe de Auditoría de Ciberseguridad OT",
        styles['Title']
    ))
    elements.append(Paragraph(
        f"Fecha: {datetime.now().strftime('%d/%m/%Y')} | "
        f"Framework: IEC 62443 / NIS2",
        styles['Normal']
    ))
    elements.append(Spacer(1, 20))
    
    # Resumen ejecutivo
    critical = sum(1 for f in findings if f.get("severity") == "HIGH")
    elements.append(Paragraph("Resumen Ejecutivo", styles['Heading2']))
    elements.append(Paragraph(
        f"Se han identificado {len(findings)} hallazgos, "
        f"de los cuales {critical} son de severidad alta. "
        f"Se recomienda abordar los hallazgos críticos en un plazo "
        f"máximo de 30 días.",
        styles['Normal']
    ))
    elements.append(Spacer(1, 15))
    
    # Tabla de hallazgos
    data = [["#", "Severidad", "Categoría", "Descripción", "Estado"]]
    for i, f in enumerate(findings, 1):
        data.append([
            str(i),
            f.get("severity", "N/A"),
            f.get("category", "N/A"),
            f.get("description", "")[:80],
            f.get("status", "Abierto")
        ])
    
    table = Table(data, colWidths=[30, 70, 90, 230, 60])
    table.setStyle(TableStyle([
        ('BACKGROUND', (0, 0), (-1, 0), colors.HexColor('#1a237e')),
        ('TEXTCOLOR', (0, 0), (-1, 0), colors.white),
        ('FONTSIZE', (0, 0), (-1, -1), 8),
        ('GRID', (0, 0), (-1, -1), 0.5, colors.grey),
        ('ROWBACKGROUNDS', (0, 1), (-1, -1), [colors.white, colors.HexColor('#f5f5f5')]),
    ]))
    elements.append(table)
    
    doc.build(elements)
    print(f"Informe generado: {output}")

# Ejemplo de uso
sample_findings = [
    {"severity": "HIGH", "category": "Acceso", "description": "PLC con contraseña de fábrica", "status": "Abierto"},
    {"severity": "HIGH", "category": "Red", "description": "Sin firewall entre IT y OT", "status": "Abierto"},
    {"severity": "MEDIUM", "category": "Firmware", "description": "HMI con firmware desactualizado (CVE-2024-1234)", "status": "Abierto"},
]
generate_report(sample_findings)

Programación de Auditorías Continuas: El Modelo de Madurez

No pases de cero a automatización total de un día para otro. Este es el camino que recomiendo:

Nivel 1 — Reactivo (donde la mayoría empieza) Auditoría manual una vez al año. Sin herramientas automatizadas. El informe es un Word de 50 páginas que nadie lee.

Nivel 2 — Repetible Scripts de descubrimiento ejecutados manualmente cada trimestre. Checklist documentada. Informe generado con plantilla.

Nivel 3 — Definido Workflow en n8n que ejecuta los scripts automáticamente cada semana. Alertas por email cuando hay hallazgos críticos. Dashboard con estado de cumplimiento.

Nivel 4 — Gestionado Monitorización continua de la red OT. Detección de cambios en tiempo real (nuevo dispositivo, puerto abierto). Integración con SIEM. KPIs de ciberseguridad en el dashboard de producción.

Nivel 5 — Optimizado Threat intelligence integrada. Simulación de ataques automatizada (en ventanas de mantenimiento). Machine learning para detección de anomalías en tráfico OT.

Mi recomendación: llega al nivel 3 en 3-6 meses. Es alcanzable y ya te pone por delante del 90% de las plantas industriales.

Preguntas Frecuentes sobre Auditorías de Ciberseguridad OT Automatizadas

¿Es seguro escanear una red OT con Nmap?

Con precauciones, sí. Usa escaneos TCP connect (-sT), evita la detección de SO (-O), limita la velocidad (—max-rate 100) y nunca escanees en horario productivo. Aun así, algunos PLCs legacy pueden reaccionar mal. Siempre haz pruebas primero en una ventana de mantenimiento controlada.

¿Qué diferencia hay entre una auditoría IT y una OT?

La principal diferencia es que en OT la disponibilidad es prioritaria sobre la confidencialidad (al revés que en IT). No puedes parchear un PLC cuando quieras, no puedes instalar antivirus en un HMI, y un escaneo agresivo puede tumbar una línea de producción. Las herramientas y la metodología deben adaptarse.

¿NIS2 obliga a hacer auditorías de ciberseguridad OT?

NIS2 exige gestión de riesgos continuada y demostrable para entidades esenciales e importantes, lo que incluye infraestructura industrial. Aunque no prescribe una frecuencia exacta, las empresas deben poder demostrar que evalúan y gestionan los riesgos de forma regular.

¿Puedo usar n8n en un entorno aislado sin internet?

Sí. n8n se puede instalar on-premise con Docker sin necesidad de conexión a internet. Solo necesitas descargar la imagen y los nodos que vayas a usar. Es la opción recomendada para redes OT que no deben tener acceso a internet.

¿Qué certificaciones ayudan para auditoría OT?

Las más relevantes son GICSP (Global Industrial Cyber Security Professional) de SANS, CSSA (Certified SCADA Security Architect) y la formación específica en IEC 62443. Para la parte de automatización, conocimientos de Python y herramientas de red son imprescindibles.

Conclusión: La Auditoría OT como Proceso Continuo

Automatizar las auditorías de ciberseguridad en entornos OT no es solo una cuestión de eficiencia: es la diferencia entre saber que tienes un problema antes de que alguien lo explote y enterarte cuando ya es tarde.

La combinación de Python para los scripts de comprobación y n8n para la orquestación y notificación te da un sistema potente, flexible y que puedes adaptar a cualquier planta. Empieza con el descubrimiento de activos y la verificación de segmentación, y ve añadiendo checks a medida que madures.

Y lo más importante: una auditoría que no genera acciones correctivas es papel mojado. Cada hallazgo debe tener un responsable, un plazo y un seguimiento. La automatización te libera tiempo para lo que de verdad importa: arreglar los problemas, no buscarlos.

¿Ya automatizas tus auditorías OT? ¿Qué herramientas usas? Comparte tu experiencia en los comentarios — en este campo, compartir conocimiento nos hace más seguros a todos.

Preguntas frecuentes

¿Qué es una auditoría de ciberseguridad OT?

Es una evaluación sistemática de la seguridad de los sistemas de tecnología operacional: PLCs, SCADA, HMIs, redes industriales y dispositivos IoT de planta. Identifica vulnerabilidades, evalúa riesgos y genera recomendaciones para proteger la infraestructura crítica de ciberataques.

¿Qué partes de una auditoría de ciberseguridad OT se pueden automatizar?

Se pueden automatizar el escaneo de red (descubrir dispositivos y puertos abiertos), la verificación de versiones de firmware, la comprobación de políticas de contraseñas, el análisis de segmentación de red IT/OT, la revisión de logs y la generación de informes. La interpretación de resultados y las recomendaciones siguen requiriendo criterio humano.

¿Cuál es la diferencia entre ciberseguridad IT y ciberseguridad OT?

En IT la prioridad es confidencialidad → integridad → disponibilidad. En OT se invierte: disponibilidad → integridad → confidencialidad, porque una parada de producción tiene impacto físico y económico inmediato. Además, los sistemas OT tienen ciclos de vida de 15-20 años, protocolos sin cifrado (Modbus, S7comm) y no pueden parchearse fácilmente.

¿Qué normativa obliga a las industrias a realizar auditorías de ciberseguridad?

La Directiva NIS2 de la UE (aplicable desde octubre 2024) obliga a empresas de sectores esenciales (energía, agua, transporte, manufactura) a implementar medidas de ciberseguridad y realizar evaluaciones periódicas. La IEC 62443 es el estándar técnico de referencia para ciberseguridad en sistemas de automatización industrial.

¿Cada cuánto tiempo debería hacerse una auditoría de ciberseguridad OT?

Lo recomendado es una auditoría completa anual como mínimo, con escaneos automatizados mensuales o semanales. Además, debe realizarse una auditoría extraordinaria tras cualquier cambio significativo en la red, instalación de nuevos equipos, o después de un incidente de seguridad.

#ciberseguridad OT #auditoría #Python #n8n #NIS2

Sigue leyendo

Ciberseguridad Industrial 5 de julio de 2026

IEC 62443: Cumplimiento en Ciberseguridad Industrial

Guía práctica de IEC 62443 para ciberseguridad industrial. Estructura, niveles de seguridad, roles y pasos concretos para cumplir la norma en tu planta OT.

Leer artículo

Ciberseguridad Industrial 4 de julio de 2026

NIS2: Automatizar Cumplimiento Normativo Industrial

Automatiza el cumplimiento NIS2 en tu planta industrial. Herramientas, workflows y pasos prácticos para cubrir los requisitos de forma eficiente.

Leer artículo