Python para Ciberseguridad: Escribe Tu Primer Script de Seguridad

TL;DR

Python es el lenguaje de programación más utilizado en ciberseguridad, presente en el 72% de los proyectos de desarrollo de herramientas de seguridad y flujos de automatización SOC. Esta guía lleva a los principiantes paso a paso para escribir sus primeros scripts de seguridad: un escáner de puertos TCP, un analizador de archivos de logs y un verificador de integridad de archivos mediante hashes. No se requiere experiencia previa en programación, solo disposición para escribir código y ejecutarlo.

Eran las 6:14 PM de un viernes cuando Marcus, un analista SOC junior con tres meses en su primer trabajo de seguridad, notó algo extraño. El panel del SIEM mostraba 847 intentos de inicio de sesión fallidos contra la misma cuenta de usuario en una ventana de 90 minutos. Diferentes IPs de origen. Mismo objetivo. Un ataque de credential stuffing de manual. Su colega senior ya se había ido por el fin de semana. El runbook indicaba extraer todas las IPs de origen, cruzarlas con feeds de inteligencia de amenazas y bloquear las direcciones maliciosas confirmadas en el firewall. Copiar manualmente 847 entradas de log, extraer IPs una por una y verificar cada una contra un feed de amenazas llevaría horas.

Marcus abrió una terminal y escribió 23 líneas de Python. El script parseó el archivo de log, extrajo las IPs de origen únicas, verificó cada una contra una API abierta de inteligencia de amenazas y generó una lista de bloqueo con las direcciones maliciosas confirmadas. Tiempo total de ejecución: 11 segundos. Lo que habría consumido toda su tarde se convirtió en un problema resuelto antes de que terminara su café.

Ese script no era elegante. No tenía manejo de errores, ni logging, ni argumentos de línea de comandos. Era funcional, rápido y resolvía un problema real. Así es como Python para ciberseguridad se ve en la práctica. No necesitas ser ingeniero de software. Necesitas ser alguien capaz de traducir un problema de seguridad en código funcional.

Por Qué Python Domina la Ciberseguridad

Python ocupa una posición única en el mundo de la seguridad porque se encuentra en la intersección de simplicidad y potencia. El SANS Institute identifica a Python como el lenguaje más recomendado para profesionales de seguridad, señalando que su sintaxis legible permite a los analistas escribir herramientas funcionales sin años de formación en programación.

Tres características hacen de Python la opción por defecto. Primero, su biblioteca estándar incluye módulos para networking, manejo de archivos, criptografía y comunicación HTTP. Puedes construir un escáner de puertos, parsear archivos de log o interactuar con APIs web sin instalar un solo paquete externo. Segundo, Python funciona en todas las plataformas que los profesionales de seguridad encuentran: Linux, Windows, macOS e incluso sistemas embebidos. Un script escrito en tu portátil funciona idénticamente en un servidor remoto. Tercero, la comunidad de seguridad ha construido miles de bibliotecas específicamente para trabajo ofensivo y defensivo, desde Scapy para fabricación de paquetes hasta Volatility para análisis forense de memoria.

El impacto práctico es medible. Según una encuesta SANS 2025, los equipos SOC que automatizan tareas repetitivas con scripting reducen su tiempo medio de respuesta (MTTR) hasta en un 40%. Cuando una amenaza surge a las 2 AM, la diferencia entre una respuesta manual de 45 minutos y una automatizada de 11 segundos es la diferencia entre contención y brecha.

Configuración de Tu Entorno Python para Seguridad

Antes de escribir cualquier código, necesitas una instalación funcional de Python y un editor de texto. Si usas Kali Linux o cualquier distribución moderna de Linux, Python 3 ya está instalado. Verifícalo abriendo una terminal y escribiendo:

python3 --version

En Windows o macOS, descarga Python desde python.org. Durante la instalación en Windows, marca la casilla «Add Python to PATH». Este paso es crítico. Sin él, tu terminal no reconocerá el comando python.

Para escribir scripts, cualquier editor de texto funciona. VS Code con la extensión de Python proporciona resaltado de sintaxis, detección de errores y una terminal integrada. Los principiantes suelen hacerlo bien con editores más simples como Nano en Linux o Notepad++ en Windows. La herramienta importa menos que el hábito de escribir código realmente.

Crea un directorio dedicado para tus scripts de seguridad:

mkdir ~/security-scripts
cd ~/security-scripts

Todos los scripts de esta guía funcionan con la biblioteca estándar de Python. No se requieren instalaciones con pip para tus tres primeros proyectos.

Tu Primer Script: Escáner de Puertos TCP

El escaneo de puertos es fundamental para las pruebas de penetración y el reconocimiento de red. Antes de poder probar la seguridad de un sistema, necesitas saber qué servicios están ejecutándose y qué puertos están abiertos. Aunque herramientas como Nmap manejan esto profesionalmente, construir tu propio escáner te enseña cómo funcionan realmente las conexiones TCP.

Una conexión TCP comienza con un handshake de tres vías. Tu máquina envía un paquete SYN, el objetivo responde con SYN-ACK si el puerto está abierto, y tu máquina completa el handshake con un ACK. Si el puerto está cerrado, el objetivo envía un paquete RST en su lugar. El módulo socket de Python maneja todo este proceso.

import socket
import sys
from datetime import datetime

def scan_port(target, port):
    """Attempt a TCP connection to a single port."""
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(1)
        result = sock.connect_ex((target, port))
        sock.close()
        return result == 0
    except socket.error:
        return False

def scan_target(target, start_port, end_port):
    """Scan a range of ports on the target host."""
    print(f"\nScanning {target}")
    print(f"Started at {datetime.now().strftime('%H:%M:%S')}")
    print("-" * 40)

    open_ports = []

    for port in range(start_port, end_port + 1):
        if scan_port(target, port):
            open_ports.append(port)
            try:
                service = socket.getservbyport(port)
            except OSError:
                service = "unknown"
            print(f"  Port {port}: OPEN ({service})")

    print(f"\nScan complete. {len(open_ports)} open port(s) found.")
    return open_ports

if __name__ == "__main__":
    target = input("Target IP or hostname: ")
    scan_target(target, 1, 1024)

Guarda esto como port_scanner.py y ejecútalo con python3 port_scanner.py. Introduce 127.0.0.1 (tu propia máquina) como objetivo para hacer pruebas de forma segura. El script intenta una conexión TCP en cada puerto del 1 al 1024, reporta los puertos abiertos con los nombres de sus servicios y te dice cuántos encontró.

Este escáner es deliberadamente simple. Las herramientas de producción como Nmap usan raw sockets, escaneo SYN y ejecución multihilo para velocidad. Pero este script demuestra el concepto central: un puerto está abierto si una conexión TCP tiene éxito. Comprender esta base te convierte en un usuario más efectivo de herramientas profesionales.

Automatización del Análisis de Logs Con Python

Los analistas SOC dedican una parte significativa de su día a leer logs. Logs de autenticación, logs de acceso a servidores web, logs de firewall y logs de aplicaciones contienen evidencia de ataques, configuraciones erróneas y anomalías. Revisar manualmente miles de líneas es lento y propenso a errores. Python convierte esto en un proceso estructurado y repetible.

El siguiente script parsea un archivo auth.log estándar, extrae los intentos fallidos de inicio de sesión SSH, cuenta los intentos por IP de origen y marca las IPs que superan un umbral:

import re
from collections import Counter

def analyze_auth_log(filepath, threshold=10):
    """Parse auth.log for failed SSH attempts and flag suspicious IPs."""
    failed_pattern = re.compile(
        r"Failed password for (?:invalid user )?(\S+) from (\d+\.\d+\.\d+\.\d+)"
    )

    attempts = []
    usernames_targeted = {}

    with open(filepath, "r") as log_file:
        for line in log_file:
            match = failed_pattern.search(line)
            if match:
                username = match.group(1)
                ip_address = match.group(2)
                attempts.append(ip_address)

                if ip_address not in usernames_targeted:
                    usernames_targeted[ip_address] = set()
                usernames_targeted[ip_address].add(username)

    ip_counts = Counter(attempts)

    print(f"Total failed login attempts: {len(attempts)}")
    print(f"Unique source IPs: {len(ip_counts)}")
    print(f"\nIPs exceeding {threshold} failed attempts:")
    print("-" * 55)

    flagged = []
    for ip, count in ip_counts.most_common():
        if count >= threshold:
            users = usernames_targeted.get(ip, set())
            print(f"  {ip:18s}  {count:4d} attempts  {len(users)} usernames")
            flagged.append(ip)

    if flagged:
        print(f"\nBlocklist ({len(flagged)} IPs):")
        for ip in flagged:
            print(ip)

    return flagged

if __name__ == "__main__":
    flagged_ips = analyze_auth_log("/var/log/auth.log", threshold=10)

El módulo re maneja la coincidencia de patrones con expresiones regulares. La clase Counter de collections cuenta ocurrencias automáticamente. Juntos, transforman un muro de texto en inteligencia accionable: qué IPs están atacando, con qué agresividad y qué nombres de usuario están apuntando.

Este script revela patrones de ataque que la revisión manual no detecta. Una IP que probó 200 nombres de usuario diferentes está ejecutando un ataque de diccionario. Una IP que probó el mismo nombre de usuario 500 veces está haciendo fuerza bruta contra una cuenta específica. La distinción importa porque cada patrón requiere una respuesta diferente.

Construcción de un Verificador de Integridad de Archivos

La monitorización de integridad de archivos detecta cambios no autorizados en archivos críticos del sistema. Cuando un malware modifica un archivo de configuración, reemplaza un binario o planta una puerta trasera, el hash criptográfico del archivo cambia. Al comparar los hashes actuales con líneas base conocidas, detectas manipulaciones que de otro modo podrían pasar desapercibidas.

La Publicación Especial 800-53 del NIST incluye la monitorización de integridad de archivos como un control de seguridad fundamental (SI-7). El módulo hashlib de Python calcula hashes usando los mismos algoritmos en los que se basan las herramientas empresariales.

import hashlib
import os
import json
from datetime import datetime

def hash_file(filepath):
    """Calculate SHA-256 hash of a file."""
    sha256 = hashlib.sha256()
    try:
        with open(filepath, "rb") as f:
            for chunk in iter(lambda: f.read(8192), b""):
                sha256.update(chunk)
        return sha256.hexdigest()
    except (PermissionError, FileNotFoundError) as e:
        return f"ERROR: {e}"

def create_baseline(directories, output_file="baseline.json"):
    """Create a hash baseline for files in specified directories."""
    baseline = {}
    file_count = 0

    for directory in directories:
        for root, dirs, files in os.walk(directory):
            for filename in files:
                filepath = os.path.join(root, filename)
                file_hash = hash_file(filepath)
                if not file_hash.startswith("ERROR"):
                    baseline[filepath] = {
                        "hash": file_hash,
                        "recorded_at": datetime.now().isoformat()
                    }
                    file_count += 1

    with open(output_file, "w") as f:
        json.dump(baseline, f, indent=2)

    print(f"Baseline created: {file_count} files recorded.")
    return baseline

def check_integrity(baseline_file="baseline.json"):
    """Compare current file hashes against the baseline."""
    with open(baseline_file, "r") as f:
        baseline = json.load(f)

    modified = []
    missing = []

    for filepath, record in baseline.items():
        if not os.path.exists(filepath):
            missing.append(filepath)
            continue

        current_hash = hash_file(filepath)
        if current_hash != record["hash"]:
            modified.append({
                "file": filepath,
                "expected": record["hash"][:16] + "...",
                "actual": current_hash[:16] + "..."
            })

    print(f"\nIntegrity Check Results")
    print(f"Files checked: {len(baseline)}")
    print(f"Modified: {len(modified)}")
    print(f"Missing: {len(missing)}")

    if modified:
        print(f"\nMODIFIED FILES:")
        for entry in modified:
            print(f"  {entry['file']}")
            print(f"    Expected: {entry['expected']}")
            print(f"    Actual:   {entry['actual']}")

    if missing:
        print(f"\nMISSING FILES:")
        for filepath in missing:
            print(f"  {filepath}")

    return modified, missing

if __name__ == "__main__":
    import sys

    if len(sys.argv) > 1 and sys.argv[1] == "check":
        check_integrity()
    else:
        dirs_to_monitor = ["/etc/ssh", "/etc/cron.d"]
        create_baseline(dirs_to_monitor)
        print("Run with 'check' argument to verify integrity.")

Ejecuta python3 integrity_checker.py para crear una línea base, luego python3 integrity_checker.py check para verificar los archivos contra ella. Cualquier modificación, incluso un cambio de un solo byte, produce un hash completamente diferente. Este es el mismo principio que impulsa herramientas como OSSEC y Tripwire.

El script lee los archivos en bloques de 8192 bytes, lo que significa que maneja archivos de cualquier tamaño sin cargarlos completamente en memoria. Almacena las líneas base como JSON, haciéndolas legibles por humanos y fáciles de integrar con otras herramientas.

Dónde Encaja Python en Tu Carrera de Seguridad

Python no es un sustituto para comprender los conceptos de seguridad. Es un amplificador. Saber cómo funciona un ataque de fuerza bruta es valioso. Escribir un script que detecta uno en tiempo real, extrae indicadores de compromiso y genera una lista de bloqueo es un diferenciador profesional.

Para aspirantes a analistas SOC, Python automatiza las tareas repetitivas que consumen tiempo de investigación: parsear logs, enriquecer IOCs con inteligencia de amenazas, generar informes y correlacionar eventos entre fuentes de datos. Para testers de penetración, Python permite el desarrollo personalizado de exploits, la generación de payloads y la automatización post-explotación. Para ingenieros de seguridad, los scripts de Python integran herramientas, automatizan despliegues y aplican políticas.

El camino a seguir tiene una progresión clara. Domina los scripts de la biblioteca estándar en esta guía. Luego explora bibliotecas externas: requests para interacción con APIs, scapy para manipulación de paquetes, paramiko para automatización SSH. Construye herramientas que resuelvan problemas que encuentres en tu propio lab o trabajo. Contribuye a proyectos de seguridad de código abierto. Cada script que escribes construye tanto habilidad como un portafolio que demuestra capacidad ante los empleadores.

Qué Construir a Continuación

Una vez que tengas funcionando los tres scripts de esta guía, amplíalos. Añade multihilo al escáner de puertos para que termine en segundos en vez de minutos. Haz que el analizador de logs acepte argumentos de línea de comandos para que funcione con diferentes formatos de log. Programa el verificador de integridad para que se ejecute cada hora con cron y envíe alertas por correo cuando se detecten cambios.

Luego aborda nuevos proyectos. Escribe un script que consulte la API de VirusTotal para verificar hashes de archivos contra firmas de malware conocidas. Construye un kit simple de respuesta a incidentes que recopile información del sistema, conexiones activas, procesos en ejecución y cambios recientes en archivos en un solo informe. Crea un analizador de fortaleza de contraseñas que verifique contraseñas contra listas de palabras comunes y calcule la entropía.

Cada script que construyes refuerza dos habilidades simultáneamente: programación en Python y pensamiento en seguridad. Aprendes a pensar como defensor y como atacante, que es exactamente lo que los empleadores quieren. El analista junior que automatizó 847 entradas de log un viernes por la tarde se convirtió en la persona de referencia del equipo para automatización en seis meses. No porque fuera el mejor programador, sino porque era el analista que podía traducir problemas de seguridad en soluciones funcionales.

Empieza con el escáner de puertos. Ejecútalo contra tu propia máquina. Lee la salida. Entiende qué significa cada puerto abierto. Ese es el primer paso de la teoría a la práctica, y Python es el puente que te lleva allí.