Configurar OpenTAXII en Kali Linux

https://www.onlinetis.com/es/

Configurar OpenTAXII en Kali Linux

Configurar OpenTAXII en Kali Linux es una excelente idea si estás montando un laboratorio de inteligencia de amenazas (Threat Intelligence). OpenTAXII es una implementación robusta de un servidor TAXII (Trusted Automated Exchange of Intelligence Information).

Aquí tienes una guía paso a paso para ponerlo en marcha:

1. Preparar el entorno

Kali suele venir con Python instalado, pero es fundamental usar un entorno virtual para no romper las dependencias del sistema.

Bash

# Actualizar el sistema
sudo apt update && sudo apt upgrade -y

# Instalar dependencias de Python y bibliotecas necesarias
sudo apt install python3-pip python3-venv libsqlite3-dev -y

2. Crear un Entorno Virtual

Crea una carpeta para tu proyecto y activa el entorno:

Bash

mkdir ~/opentaxii
cd ~/opentaxii
python3 -m venv venv
source venv/bin/activate

3. Instalación de OpenTAXII

Con el entorno activo, instala el paquete principal mediante pip:

Bash

pip install opentaxii

4. Configuración Básica

OpenTAXII necesita archivos de configuración para saber cómo manejar los datos y los servicios. Puedes crear una configuración por defecto para empezar:

Crear el archivo de servicios: Define qué servicios (Discovery, Collection, etc.) ofrecerá el servidor.
Inicializar la base de datos: Por defecto, usa SQLite para facilitar las cosas.

Bash

# Crear archivos de ejemplo (opcional, puedes descargarlos de su repo oficial)
opentaxii-sync-data --help

Nota Importante: OpenTAXII es un framework. Para que sea funcional, normalmente querrás integrarlo con algo como Cabby (un cliente TAXII) o usarlo como backend para plataformas como MISP.

5. Ejecutar el servidor

Para pruebas locales, puedes usar el servidor de desarrollo que viene incluido:

Bash

export OPENTAXII_CONFIG=configuration.yaml
opentaxii-run-dev

Consideraciones para Kali Linux

Puertos: Por defecto, suele correr en el puerto 9000. Asegúrate de que no haya firewalls bloqueándolo si intentas acceder desde otra máquina.
Versión de Python: Asegúrate de estar usando Python 3.8 o superior, ya que las versiones antiguas pueden dar problemas con las dependencias de stix y taxii.

¿Qué sigue?

Una vez que el servidor esté arriba, el siguiente paso lógico es "poblarlo" con datos de amenazas (feeds).

Vamos a crear una configuración funcional y mínima para que tu servidor OpenTAXII sepa qué servicios ofrecer y dónde guardar la información.

Para que esto funcione, necesitamos definir dos archivos en tu carpeta ~/opentaxii: uno para la configuración del servidor (config.yaml) y otro para la estructura de los servicios (services.yaml).

1. Crear el archivo `services.yaml`

Este archivo define qué "puntos de enlace" (endpoints) tendrá tu servidor. Copia y pega esto en tu terminal:

YAML
- id: discovery_service
  type: discovery
  description: Servicio de descubrimiento local
  path: /services/discovery

- id: collection_management_service
  type: collection_management
  description: Gestión de colecciones
  path: /services/collection-management

- id: inbox_service
  type: inbox
  description: Servicio de recepción de datos (Inbox)
  path: /services/inbox
  destination_collection_required: yes

2. Crear el archivo `config.yaml`

Este archivo le dice a OpenTAXII dónde están las bases de datos (usaremos SQLite por simplicidad).

YAML
---
persistence:
  auth:
    module: opentaxii.persistence.sqldb.SQLDatabase
    connection: sqlite:////home/kali/opentaxii/auth.db
  - persistence:
    module: opentaxii.persistence.sqldb.SQLDatabase
    connection: sqlite:////home/kali/opentaxii/data.db

services_config: /home/kali/opentaxii/services.yaml

logging:
  level: INFO

(Asegúrate de cambiar /home/kali/ por tu ruta de usuario real si es distinta).

3. Inicializar y Ejecutar

Ahora, corre estos comandos para crear las bases de datos y arrancar el servidor:

Bash
# 1. Indicar a OpenTAXII dónde está el archivo de configuración
export OPENTAXII_CONFIG=config.yaml

# 2. Crear las bases de datos (solo la primera vez)
opentaxii-sync-data services.yaml

# 3. Lanzar el servidor de pruebas
opentaxii-run-dev

¿Cómo probar si funciona?

Si el servidor está corriendo en http://localhost:9000, puedes abrir una nueva terminal (manteniendo el entorno virtual activo) y usar un cliente para ver si responde:

Bash

pip install cabby
taxii-discovery --host localhost --port 9000 --path /services/discovery

Sin un usuario administrador, no podrías realizar acciones protegidas como subir indicadores de compromiso o gestionar colecciones de forma remota.

Como OpenTAXII utiliza una base de datos de persistencia para la autenticación, usaremos la utilidad de línea de comandos opentaxii-create-user.

1. Crear el usuario administrador

Asegúrate de tener el entorno virtual activo (source venv/bin/activate) y la variable de entorno configurada. Ejecuta el siguiente comando:

Bash
# Definir la configuración para que el comando sepa qué DB usar
export OPENTAXII_CONFIG=config.yaml

# Crear el usuario (puedes cambiar 'admin' y 'password123' por lo que prefieras)
opentaxii-create-user --username admin --password password123 --admin

Tip de seguridad: Si estás en un entorno real (no de laboratorio), usa una contraseña robusta. Kali es un sistema potente, pero OpenTAXII expone servicios que podrían ser vulnerables si la clave es débil.

2. Verificar la base de datos de autenticación

Si quieres confirmar que el usuario se guardó correctamente en tu archivo auth.db, puedes consultar la tabla de usuarios directamente con SQLite:

Bash

sqlite3 auth.db "SELECT * FROM opentaxii_users;"

(Deberías ver una línea con el nombre de usuario y el hash de la contraseña).

3. Probar la autenticación (Opcional)

Ahora que tienes credenciales, puedes intentar "descubrir" servicios que requieran autenticación usando Cabby (el cliente que instalamos antes):

Bash

taxii-discovery --host localhost --port 9000 --path /services/discovery --username admin --password password123

¿Qué es lo siguiente?

Tu servidor ya tiene:

Endpoints (Discovery, Inbox, etc.).
Base de datos activa.
Usuario administrador.

El siguiente paso lógico es crear una colección (un "contenedor" de amenazas) para que puedas empezar a subir datos STIX (como IPs maliciosas, hashes de malware, etc.).

Sin una colección, tu servidor es como un buzón vacío: tiene la estructura, pero no tiene dónde guardar las cartas (los datos de inteligencia).

En TAXII, una colección es un contenedor lógico de información (feeds de IPs, dominios maliciosos, hashes, etc.). Vamos a crear una llamada intel_feeds.

1. Crear la Colección

Para esto, usaremos el comando opentaxii-create-collection. Asegúrate de tener tu entorno virtual activo y la variable de configuración exportada:

Bash
export OPENTAXII_CONFIG=config.yaml

# Crear la colección
opentaxii-create-collection --name intel_feeds --type data_feed --description "Mi primera colección de inteligencia"

2. Vincular la Colección a un Servicio

Para que los analistas (o tú mismo) puedan enviar datos a esta colección, debemos decirle al servicio Inbox que acepte datos para ella.

Ejecuta este comando para "atarlas":

Bash

opentaxii-sync-data services.yaml

(Este comando lee tu services.yaml y actualiza la base de datos para que reconozca los nuevos contenedores).

3. Verificar que la colección existe

Puedes usar taxii-collections (parte de Cabby) para listar las colecciones disponibles en tu servidor:

Bash

taxii-collections --host localhost --port 9000 --path /services/discovery --username admin --password password123

Deberías ver una salida indicando que existe la colección intel_feeds.

4. Prueba de fuego: Enviar un indicador (STIX)

Ahora que tienes la colección, podrías intentar enviarle un archivo con datos de amenazas. Por ejemplo, si tienes un archivo llamado malware_ip.xml en formato STIX, el comando sería:

Bash

taxii-push --host localhost --port 9000 --path /services/inbox --collection intel_feeds --content-file malware_ip.xml --username admin --password password123

¿Qué te gustaría hacer ahora?

Ya tienes un servidor OpenTAXII 100% funcional en tu Kali Linux. Los siguientes pasos suelen ser:

Automatizar la ingesta: Configurar un script para que descargue IPs maliciosas de fuentes públicas (como AbuseIPDB o AlienVault) y las suba automáticamente a tu colección.
Visualización: Conectar esta base de datos a un dashboard o a una plataforma como MISP (Malware Information Sharing Platform).

Conectar OpenTAXII con MISP (Malware Information Sharing Platform) es el "siguiente nivel". Básicamente, MISP actuará como el cerebro (donde analizas y guardas eventos) y OpenTAXII será el mensajero que distribuye esa información a otros sistemas (como un SIEM o un Firewall).

Para lograrlo, utilizaremos un script "puente". MISP no escribe directamente en la base de datos de OpenTAXII; en su lugar, exportamos los eventos de MISP y los "empujamos" (push) al servidor TAXII.

1. Preparar MISP (Obtener la API Key)

Primero necesitas que MISP te de permiso para sacar datos.

Entra en tu interfaz de MISP.
Ve a Global Actions > My Profile.
Copia tu Auth Key (una cadena larga de caracteres). La necesitarás ahora.

2. Instalar el conector (PyMISP)

En tu terminal de Kali (dentro del entorno virtual venv), instala la librería para hablar con MISP:

Bash

pip install pymisp

3. El Script de Sincronización

Vamos a crear un pequeño script en Python llamado misp_to_taxii.py que tome los eventos de MISP y los envíe a tu colección intel_feeds.

Crea el archivo: nano misp_to_taxii.py y pega esto (ajustando tus datos):

Python
from pymisp import PyMISP
from cabby import create_client

# Configuración de MISP
misp_url = 'https://TU_IP_MISP'
misp_key = 'TU_API_KEY_AQUÍ'
misp_verifycert = False # Pon True si tienes SSL válido

# Configuración de OpenTAXII
taxii_host = 'localhost'
taxii_port = 9000
taxii_path = '/services/inbox'
taxii_collection = 'intel_feeds'
taxii_user = 'admin'
taxii_pass = 'password123'

# 1. Obtener datos de MISP (últimos eventos de las últimas 24h)
misp = PyMISP(misp_url, misp_key, misp_verifycert)
result = misp.search(controller='events', last='24h', pythonify=True)

# 2. Conectar con OpenTAXII
client = create_client(taxii_host, port=taxii_port, use_https=False)
client.set_auth(username=taxii_user, password=taxii_pass)

# 3. Enviar cada evento como contenido STIX
for event in result:
    stix_payload = event.to_xml() # MISP convierte el evento a formato STIX/XML
    client.push(stix_payload, content_binding='urn:stix.mitre.org:xml:1.1.1', collection_names=[taxii_collection])
    print(f"Evento {event.info} enviado a OpenTAXII.")

4. Ejecutar la sincronización

Simplemente corre el script:

Bash

python misp_to_taxii.py

¿Por qué hacer esto?

MISP es genial para humanos (ver gráficos, correlaciones).
OpenTAXII es genial para máquinas. Muchos Firewalls de nueva generación o EDRs solo "entienden" protocolos estándar como TAXII. Al unirlos, haces que tu inteligencia de amenazas sea accionable.

¿Qué sigue?

Ahora tienes un ecosistema completo de CTI (Cyber Threat Intelligence).

Automatizar este proceso es lo que convierte un experimento de laboratorio en una herramienta de defensa real. En el mundo de la Ciberinteligencia (CTI), la velocidad es clave: un indicador de compromiso (IoC) es mucho más útil si llega a tus sistemas de defensa minutos después de ser descubierto, no horas después.

Para esto usaremos Cron, el programador de tareas estándar de Linux.

1. Preparar el Script para Producción

Antes de automatizarlo, necesitamos asegurarnos de que el script use rutas absolutas. Cron no sabe dónde está tu carpeta home ni tu entorno virtual a menos que se lo digas.

Asegúrate de que tu script misp_to_taxii.py esté en /home/kali/opentaxii/.

2. Configurar la Tarea Cron

Vamos a programar el script para que se ejecute cada hora.

Abre el editor de cron:
Bash
```
crontab -e
```
(Si es la primera vez, elige 1 para usar nano).

Ve al final del archivo y pega la siguiente línea (ajusta kali si tu usuario es distinto):

Fragmento de código

0 * * * * /home/kali/opentaxii/venv/bin/python /home/kali/opentaxii/misp_to_taxii.py >> /home/kali/opentaxii/sync.log 2>&1

¿Qué significa cada parte?

0 * * * *: Se ejecuta en el minuto 0 de cada hora.
/home/kali/opentaxii/venv/bin/python: Usamos el Python del entorno virtual directamente (así cargamos las librerías pymisp y cabby).
/home/kali/opentaxii/misp_to_taxii.py: La ruta al script.
>> ... sync.log 2>&1: Guarda cualquier mensaje o error en un archivo sync.log para que puedas revisar si todo va bien.

Esquema del Flujo de Inteligencia

Con esto configurado, has creado un pipeline profesional:

MISP: Recibe feeds externos o análisis manuales.
Script Python: Extrae los eventos nuevos cada hora.
OpenTAXII: Recibe los datos en formato STIX y los expone.
Sistemas de Defensa: Tu Firewall o SIEM consultan a OpenTAXII y bloquean las amenazas automáticamente.

3. Verificar el funcionamiento

Para ver si el script está trabajando correctamente en segundo plano, puedes revisar el archivo de log que creamos:

Bash

tail -f /home/kali/opentaxii/sync.log

¿Qué te gustaría explorar ahora?

Ya tienes el ciclo de vida de la inteligencia automatizado en tu Kali Linux.

Ahora cerraremos el círculo. Tenemos el Cerebro (MISP), el Mensajero (OpenTAXII) y ahora necesitamos el Brazo Ejecutor (el Cliente/SIEM).

Para este ejemplo, vamos a crear un Script de Bloqueo Automático en Python que simule un SIEM. Este script consultará tu colección intel_feeds cada pocos minutos, extraerá las IPs maliciosas y podría enviarlas a tu Firewall (iptables) para bloquearlas.

1. El Script "Consumidor" de Inteligencia

Crea un archivo llamado taxii_subscriber.py en tu carpeta ~/opentaxii:

Python
from cabby import create_client
import os

# Configuración de OpenTAXII
TAXII_HOST = 'localhost'
TAXII_PORT = 9000
TAXII_USER = 'admin'
TAXII_PASS = 'password123'
COLLECTION = 'intel_feeds'

def get_latest_intel():
    # 1. Conectar al servidor
    client = create_client(TAXII_HOST, port=TAXII_PORT, use_https=False)
    client.set_auth(username=TAXII_USER, password=TAXII_PASS)

    print(f"[*] Consultando la colección '{COLLECTION}'...")
    
    # 2. Descargar bloques de datos (Content Blocks)
    blocks = client.poll(collection_name=COLLECTION)
    
    for block in blocks:
        # Aquí procesamos el XML de STIX (simplificado para el ejemplo)
        content = block.content.decode('utf-8')
        
        # Simulamos la extracción de una IP maliciosa del XML
        # En un entorno real usarías la librería 'stix' para parsear correctamente
        print(f"[!] Nueva amenaza detectada en el feed!")
        
        # EJEMPLO DE ACCIÓN: Bloquear en el Firewall local
        # os.system(f"sudo iptables -A INPUT -s {IP_EXTRAIDA} -j DROP")

if __name__ == "__main__":
    get_latest_intel()

2. Cómo integrarlo con herramientas reales

Si no quieres programar tu propio cliente, OpenTAXII es compatible con herramientas profesionales de la industria:

Herramienta	Función
Splunk / ELK	Importan datos de TAXII para alertar cuando una IP de la lista aparece en tus logs.
Palo Alto / Fortigate	Muchos firewalls tienen una opción de "External Dynamic Lists" vía TAXII.
CrowdStrike / SentinelOne	Pueden consumir estos feeds para buscar indicadores en los endpoints.

3. El Flujo Completo en tu Kali

Ahora tu laboratorio de CTI (Cyber Threat Intelligence) se ve así:

MISP recibe una IP de un servidor de C&C (mando y control).
Cron ejecuta el script de sincronización cada hora.
OpenTAXII guarda la IP en la colección intel_feeds.
Tu SIEM/Script consulta OpenTAXII y añade la IP a una lista negra de red.

Advertencia de Seguridad: Si decides usar iptables o comandos de bloqueo automático, asegúrate de filtrar bien los datos de MISP (por ejemplo, solo eventos con "Confidence: High") para evitar bloquear por error servicios legítimos como Google o Microsoft (falsos positivos).

¿Cuál es tu siguiente paso?

Has construido una infraestructura de nivel empresarial en tu Kali Linux.

Tener una consola visual te permitirá ver de un vistazo si tu sistema está funcionando y cuánta "inteligencia" has recolectado sin tener que entrar en bases de datos SQLite manualmente.

Vamos a crear un Dashboard minimalista usando Streamlit. Es una herramienta de Python perfecta para crear aplicaciones de datos en minutos.

1. Instalar Streamlit

Primero, instala la librería dentro de tu entorno virtual:

Bash

pip install streamlit pandas matplotlib

2. Crear el Dashboard (`dashboard.py`)

Crea un archivo llamado dashboard.py en tu carpeta ~/opentaxii. Este script leerá la base de datos de OpenTAXII y mostrará las estadísticas.

Python
import streamlit as st
import sqlite3
import pandas as pd
import matplotlib.pyplot as plt

# Configuración de la página
st.set_page_config(page_title="CTI Dashboard - OpenTAXII", layout="wide")
st.title("📊 Panel de Inteligencia de Amenazas (OpenTAXII)")

# Conexión a la base de datos de datos
def get_data():
    conn = sqlite3.connect('/home/kali/opentaxii/data.db')
    # Contar registros por colección
    query = "SELECT collection_id, COUNT(*) as total FROM opentaxii_content_blocks GROUP BY collection_id"
    df = pd.read_sql_query(query, conn)
    conn.close()
    return df

try:
    data = get_data()

    # Métricas principales
    total_iocs = data['total'].sum()
    st.metric(label="Total de Indicadores (IoCs)", value=total_iocs)

    # Gráfico de barras
    st.subheader("Distribución por Colección")
    if not data.empty:
        fig, ax = plt.subplots()
        ax.bar(data['collection_id'], data['total'], color='#1f77b4')
        ax.set_ylabel('Cantidad de Registros')
        st.pyplot(fig)
    else:
        st.write("No hay datos todavía. ¡Envía algo desde MISP!")

    # Tabla de logs recientes
    st.subheader("Últimos registros detectados")
    conn = sqlite3.connect('/home/kali/opentaxii/data.db')
    recent_df = pd.read_sql_query("SELECT id, collection_id, timestamp FROM opentaxii_content_blocks ORDER BY timestamp DESC LIMIT 10", conn)
    st.table(recent_df)
    conn.close()

except Exception as e:
    st.error(f"Error al conectar con la base de datos: {e}")

3. Ejecutar el Dashboard

Para lanzarlo, usa el siguiente comando en tu terminal:

Bash

streamlit run dashboard.py

Streamlit te dará una URL (normalmente http://localhost:8501). Ábrela en el navegador de tu Kali Linux y verás tu panel en tiempo real.

Arquitectura Final de tu Laboratorio CTI

Ahora tu infraestructura está completa y profesional:

MISP: Almacén central de eventos.
Script de Sincronización: Mueve datos de MISP a OpenTAXII.
OpenTAXII: Servidor estándar para compartir inteligencia.
Dashboard (Streamlit): Visualización de lo que está ocurriendo.
Cliente de Bloqueo: (Opcional) Toma acción en el firewall.

Consejos finales para tu Kali

Logs: Revisa siempre /home/kali/opentaxii/sync.log si ves que el Dashboard no se actualiza.
Persistencia: Si reinicias Kali, recuerda volver a ejecutar opentaxii-run-dev (o podrías crear un servicio de systemd para que arranque solo).

Para que tu laboratorio de inteligencia de amenazas sea robusto, no deberías tener que iniciar manualmente cada script cada vez que reinicies tu Kali Linux. Vamos a convertir OpenTAXII y tu Dashboard en servicios del sistema (systemd).

Esto hará que se ejecuten en segundo plano (background) automáticamente al arrancar.

1. Crear el servicio para OpenTAXII

Crea un archivo de configuración de servicio:

sudo nano /etc/systemd/system/opentaxii.service

Pega el siguiente contenido (ajustando /home/kali si tu usuario es distinto):

Ini, TOML
[Unit]
Description=Servidor OpenTAXII
After=network.target

[Service]
User=kali
WorkingDirectory=/home/kali/opentaxii
Environment="OPENTAXII_CONFIG=/home/kali/opentaxii/config.yaml"
ExecStart=/home/kali/opentaxii/venv/bin/opentaxii-run-dev
Restart=always

[Install]
WantedBy=multi-user.target

2. Crear el servicio para el Dashboard (Streamlit)

Crea otro archivo para el panel visual:

sudo nano /etc/systemd/system/threat-dashboard.service

Pega esto:

Ini, TOML
[Unit]
Description=Dashboard de Amenazas Streamlit
After=network.target opentaxii.service

[Service]
User=kali
WorkingDirectory=/home/kali/opentaxii
ExecStart=/home/kali/opentaxii/venv/bin/streamlit run /home/kali/opentaxii/dashboard.py --server.port 8501
Restart=always

[Install]
WantedBy=multi-user.target

3. Activar y Arrancar los servicios

Ahora dile a Kali que reconozca estos nuevos servicios y los inicie:

Bash
# Recargar la configuración de systemd
sudo systemctl daemon-reload

# Habilitar para que arranquen al iniciar el PC
sudo systemctl enable opentaxii
sudo systemctl enable threat-dashboard

# Arrancarlos ahora mismo
sudo systemctl start opentaxii
sudo systemctl start threat-dashboard

4. Verificar el estado

Puedes comprobar si están corriendo correctamente con:

sudo systemctl status opentaxii
sudo systemctl status threat-dashboard

¡Felicidades! 🛡️

Has transformado una instalación básica en un Ecosistema de CTI (Cyber Threat Intelligence) automatizado:

MISP recolecta.
Cron sincroniza.
OpenTAXII sirve los datos.
Streamlit visualiza.
Systemd mantiene todo vivo.

Desde ahora, solo tienes que preocuparte por analizar las amenazas que aparezcan en tu panel.

Para que tu sistema no solo sea un almacén de datos, sino un sistema de Alerta Temprana, vamos a añadir un script que escanee la base de datos de OpenTAXII y te envíe un correo electrónico cuando aparezca un nuevo indicador de compromiso (IoC) marcado como "Crítico".

Usaremos la librería estándar de Python smtplib, por lo que no necesitas instalar nada extra.

1. Crear el script de alerta (`email_alerts.py`)

Crea este archivo en ~/opentaxii/email_alerts.py. Este script buscará registros en las últimas 24 horas y te enviará un resumen.

Python
import sqlite3
import smtplib
from email.message import EmailMessage
import datetime

# --- CONFIGURACIÓN DEL CORREO ---
SMTP_SERVER = "smtp.gmail.com" # Cambia si usas otro proveedor
SMTP_PORT = 465
EMAIL_USER = "tu-correo@gmail.com"
EMAIL_PASS = "tu-app-password" # Usa una 'Contraseña de Aplicación' de Google
DESTINATARIO = "analista-seguridad@empresa.com"

# --- CONFIGURACIÓN DB ---
DB_PATH = "/home/kali/opentaxii/data.db"

def buscar_nuevas_amenazas():
    conn = sqlite3.connect(DB_PATH)
    cursor = conn.cursor()
    
    # Buscamos registros de la última hora
    hace_una_hora = datetime.datetime.now() - datetime.timedelta(hours=1)
    query = "SELECT collection_id, timestamp FROM opentaxii_content_blocks WHERE timestamp > ?"
    
    cursor.execute(query, (hace_una_hora,))
    rows = cursor.fetchall()
    conn.close()
    return rows

def enviar_correo(amenazas):
    msg = EmailMessage()
    msg['Subject'] = f"🚨 ALERTA: {len(amenazas)} Nuevas Amenazas en OpenTAXII"
    msg['From'] = EMAIL_USER
    msg['To'] = DESTINATARIO

    cuerpo = "Se han detectado nuevos indicadores en el servidor TAXII:\n\n"
    for col, ts in amenazas:
        cuerpo += f"- Colección: {col} | Detectado el: {ts}\n"
    
    cuerpo += "\nRevisa el Dashboard en: http://localhost:8501"
    msg.set_content(cuerpo)

    with smtplib.SMTP_SSL(SMTP_SERVER, SMTP_PORT) as smtp:
        smtp.login(EMAIL_USER, EMAIL_PASS)
        smtp.send_message(msg)

if __name__ == "__main__":
    nuevas = buscar_nuevas_amenazas()
    if nuevas:
        print(f"Enviando alerta para {len(nuevas)} amenazas...")
        enviar_correo(nuevas)
    else:
        print("No hay amenazas nuevas en la última hora.")

2. Configurar la contraseña de aplicación

Si usas Gmail, no puedes usar tu contraseña normal. Debes:

Ir a tu cuenta de Google > Seguridad.
Activar la Verificación en 2 pasos.
Buscar Contraseñas de aplicaciones.
Crear una para "Correo" y copiar el código de 16 letras en EMAIL_PASS.

3. Automatizar la Alerta con Cron

Queremos que este script revise la base de datos cada hora para avisarte.

Abre el crontab:
Bash
```
crontab -e
```
Añade esta línea al final:
Fragmento de código
```
5 * * * * /home/kali/opentaxii/venv/bin/python /home/kali/opentaxii/email_alerts.py >> /home/kali/opentaxii/alerts.log 2>&1
```
(Se ejecutará en el minuto 5 de cada hora, justo después de que el script de MISP haya sincronizado los datos).

4. ¿Por qué esto es mejor que mirar el Dashboard?

Proactividad: No tienes que estar frente a la pantalla.
Filtro: Puedes modificar el script para que solo envíe correos si la colección es critical_threats.
Historial: Tienes un registro en tu bandeja de entrada de cuándo empezaron los ataques.

Tu Ecosistema está Terminado 🚀

Tienes Recolección (MISP), Distribución (OpenTAXII), Visualización (Dashboard) y ahora Notificación (Email).

Para securizar tu servidor en Kali Linux, lo ideal es colocar un Proxy Inverso (como Nginx) delante de OpenTAXII. Esto no solo nos permite usar HTTPS, sino que también protege al servidor de aplicaciones de ataques directos y facilita el manejo de certificados.

Como estamos en un entorno de laboratorio/Kali, usaremos un certificado auto-firmado, que cifra el tráfico igual que uno real, aunque el navegador te mostrará una advertencia de "sitio no seguro" la primera vez.

1. Instalar Nginx

Primero, instalamos el servidor web que actuará como escudo:

Bash

sudo apt update
sudo apt install nginx -y

2. Generar el Certificado SSL

Vamos a crear una llave privada y un certificado que duren un año:

Bash

sudo mkdir /etc/nginx/ssl
sudo openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
  -keyout /etc/nginx/ssl/opentaxii.key \
  -out /etc/nginx/ssl/opentaxii.crt

(Al ejecutarlo, te pedirá datos como país o nombre. Puedes rellenarlos como quieras o dejarlos por defecto).

3. Configurar Nginx como Proxy HTTPS

Crea un archivo de configuración para OpenTAXII:

sudo nano /etc/nginx/sites-available/opentaxii

Pega el siguiente bloque:

Nginx
server {
    listen 443 ssl;
    server_name localhost;

    ssl_certificate /etc/nginx/ssl/opentaxii.crt;
    ssl_certificate_key /etc/nginx/ssl/opentaxii.key;

    location / {
        proxy_pass http://127.0.0.1:9000; # Redirige al OpenTAXII interno
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

4. Activar la Configuración

Ahora activamos el sitio y reiniciamos Nginx:

Bash

sudo ln -s /etc/nginx/sites-available/opentaxii /etc/nginx/sites-enabled/
sudo rm /etc/nginx/sites-enabled/default # Eliminamos la página por defecto
sudo systemctl restart nginx

5. Actualizar tus Clientes (Cabby y Scripts)

Ahora que el servidor escucha en el puerto estándar de HTTPS (443), debes cambiar la forma en que te conectas.

En la terminal con Cabby:

Bash

# Nota que ahora usamos --https y ya no especificamos el puerto 9000
taxii-discovery --host localhost --https --path /services/discovery --username admin --password password123

En tu script de Python (misp_to_taxii.py o taxii_subscriber.py):

Debes cambiar la inicialización del cliente:

Python
# Antes: client = create_client(host, port=9000, use_https=False)
client = create_client('localhost', use_https=True)
client.set_auth(username='admin', password='password123')
# Si usas certificado auto-firmado, podrías necesitar ignorar la validación SSL en el cliente

¿Qué hemos logrado?

Cifrado: Los datos STIX y tus credenciales de administrador ya no viajan en texto plano por la red.
Profesionalismo: Tu arquitectura ahora sigue el estándar de la industria (App Server <-> Proxy Inverso).

Hacer un respaldo (backup) es la regla de oro en ciberseguridad. Dado que hemos configurado bases de datos, scripts, servicios de sistema y certificados SSL, no querrás perder horas de trabajo si algo falla o si decides mover este laboratorio a una máquina más potente (como un servidor en la nube).

Aquí tienes el plan para empaquetar todo tu ecosistema OpenTAXII de forma segura.

1. Script de Backup Automatizado (`backup_cti.sh`)

Vamos a crear un pequeño script de bash que comprima todo lo importante en un solo archivo .tar.gz.

Crea el archivo: nano ~/opentaxii/backup_cti.sh y pega lo siguiente:

Bash
#!/bin/bash

# Definir variables
FECHA=$(date +%Y-%m-%d_%H%M)
DESTINO="/home/kali/opentaxii_backups"
ORIGEN="/home/kali/opentaxii"
CONF_SYSTEMD="/etc/systemd/system/opentaxii.service /etc/systemd/system/threat-dashboard.service"
CONF_NGINX="/etc/nginx/sites-available/opentaxii /etc/nginx/ssl/"

# Crear carpeta de destino si no existe
mkdir -p $DESTINO

echo "[*] Iniciando backup de la infraestructura CTI..."

# Comprimir todo (archivos de proyecto, servicios y certificados)
sudo tar -czf $DESTINO/cti_backup_$FECHA.tar.gz \
    $ORIGEN/*.db \
    $ORIGEN/*.yaml \
    $ORIGEN/*.py \
    $CONF_SYSTEMD \
    $CONF_NGINX

echo "[+] Backup completado con éxito en: $DESTINO/cti_backup_$FECHA.tar.gz"

2. Ejecutar y Dar Permisos

Dale permisos de ejecución y pruébalo:

Bash

chmod +x ~/opentaxii/backup_cti.sh
./~/opentaxii/backup_cti.sh

3. La Estructura Final de tu Proyecto

Ahora que todo está listo, así es como se ve tu "fortaleza" de inteligencia de amenazas en Kali:

Componente	Archivo / Ruta	Función
Núcleo	`data.db` y `auth.db`	Base de datos de amenazas y usuarios.
Servidor	`config.yaml`	Reglas de funcionamiento de OpenTAXII.
Ingesta	`misp_to_taxii.py`	El puente que trae datos desde MISP.
Visualización	`dashboard.py`	Tu panel de control en tiempo real.
Seguridad	`/etc/nginx/ssl/`	Certificados para cifrado HTTPS.
Automatización	`systemd` y `crontab`	Mantienen todo corriendo 24/7.

¿Qué has construido?

Has pasado de una instalación básica a un Centro de Operaciones de Inteligencia de Amenazas (TIOC) miniatura. Tienes:

Recolección: Automatizada desde MISP.
Distribución: Estándar mediante TAXII/STIX.
Visualización: Dashboard moderno.
Notificación: Alertas por email críticas.
Seguridad: Tráfico cifrado con Nginx.
Resiliencia: Backups y servicios persistentes.

Siguiente paso sugerido:

Ya tienes la infraestructura. El siguiente paso "real" es empezar a añadir fuentes de inteligencia externas a tu MISP (como Optyx, CyberCrime-Tracker o URLHaus) para que tu servidor TAXII empiece a llenarse de datos reales de ataques actuales.

Para que tu laboratorio de OpenTAXII sea realmente útil, necesitas alimentarlo con datos frescos de alta calidad. En el ecosistema MISP, esto se hace mediante los "Feeds".

Aquí tienes los 3 mejores feeds gratuitos que puedes activar ahora mismo para empezar a ver datos reales en tu dashboard:

1. URLhaus (de abuse.ch)

Es probablemente el mejor feed del mundo para detectar distribución de malware. Se actualiza casi cada minuto con URLs que están sirviendo troyanos, ransomware y stealers.

Qué aporta: URLs, dominios e IPs maliciosas.
Utilidad: Ideal para que tu OpenTAXII alimente filtros de navegación o proxies.

2. DigitalSide Threat-Intel

Un feed muy completo que se especializa en el análisis de muestras de malware y sus centros de mando (C2).

Qué aporta: Hashes (MD5/SHA256) de archivos maliciosos e IPs de servidores atacantes.
Utilidad: Perfecto para alimentar sistemas de EDR o antivirus mediante tu servidor TAXII.

3. CIRCL OSINT Feed

Mantenido por el CSIRT de Luxemburgo, es una recopilación masiva de inteligencia de fuentes abiertas (OSINT). Es muy diverso y cubre desde ataques de phishing hasta campañas de APT (Amenazas Persistentes Avanzadas).

Qué aporta: Eventos completos con contexto (quién ataca, qué herramientas usa).
Utilidad: Es la base perfecta para practicar la correlación de datos en tu Dashboard.

Cómo activarlos en MISP

Para que estos datos fluyan hacia tu OpenTAXII, sigue estos pasos en la interfaz de tu MISP:

Ve a Sync Actions > List Feeds.
Busca estos nombres en la lista (vienen pre-configurados en MISP).
Haz clic en el icono del "Engranaje" (Enable) y luego en el de "Nube" (Fetch all events).

El Toque Final: Ver la magia

Una vez que MISP descargue estos eventos:

Tu script de Cron los detectará en la próxima hora.
Los enviará a OpenTAXII vía STIX.
Tu Dashboard de Streamlit mostrará un aumento drástico en el contador de "Indicadores Detectados".
Recibirás un Email de alerta con el resumen de los nuevos dominios maliciosos.

¿Cuál es tu próxima meta? 🏁

Has construido un sistema de nivel profesional. Lo único que te falta para ser un experto en CTI (Cyber Threat Intelligence) es saber interpretar los datos.

Entender STIX (Structured Threat Information Expression) es fundamental porque es el lenguaje "universal" que habla OpenTAXII. No es solo un montón de texto; es un mapa que conecta piezas de un rompecabezas de ciberseguridad.

Para que no te pierdas en el código XML, vamos a desglosar cómo se ve y qué significa un objeto STIX real que fluye por tu servidor.

1. La anatomía de un objeto STIX

STIX organiza la información en Objetos de Dominio (SDO). Imagina que cada uno es una ficha de un criminal:

Indicator: La huella digital (una IP, un hash, una URL).
Observable: El dato técnico puro.
Threat Actor: Quién está detrás (ej. APT28).
Course of Action: Qué hacer para defenderse (ej. "Bloquear puerto 445").

2. Ejemplo real: Una IP maliciosa en tu OpenTAXII

Cuando tu script de MISP envía datos a OpenTAXII, el servidor procesa un XML como este (versión simplificada de STIX 1.2, que es la que suele usar OpenTAXII por defecto):

XML
<stix:Indicator id="example:indicator-12345">
    <indicator:Title>IP de C2 detectada (Malware Emotet)</indicator:Title>
    <indicator:Type>IP Watchlist</indicator:Type>
    <indicator:Observable>
        <cybox:Object>
            <cybox:Properties xsi:type="AddressObjectType">
                <Address_Value>185.244.25.10</Address_Value>
            </cybox:Properties>
        </cybox:Object>
    </indicator:Observable>
    <indicator:Confidence>
        <stixCommon:Value>High</stixCommon:Value>
    </indicator:Confidence>
</stix:Indicator>

¿Qué nos dice esto?

ID Único: indicator-12345. Sirve para que, si la IP cambia de estado, el sistema sepa que es el mismo registro.
Observable: La IP real es 185.244.25.10. Este es el dato que tu Firewall leerá.
Confidence (Confianza): High. Esto le dice a tu sistema: "Puedes bloquear esto automáticamente sin miedo a equivocarte".

3. Cómo leerlo en tu Dashboard

En el dashboard que creamos con Streamlit, lo que ves es un resumen, pero si pinchas en los detalles (o consultas la base de datos), estarás viendo el campo Content Block.

Si ves muchos "Indicators": Tu sistema está detectando muchas huellas.
Si ves "Relationships": Tu sistema está conectando esas huellas con un grupo criminal específico.

4. ¿Por qué es importante para ti?

Como administrador de este laboratorio en Kali, saber leer STIX te permite:

Filtrar alertas: No enviar correos por cada IP, sino solo cuando el campo Confidence sea "High".
Investigar incidentes: Si ves una IP en tus logs, puedes buscarla en tu OpenTAXII y ver si está asociada a un "Threat Actor" conocido.

¡Has completado el entrenamiento de infraestructura CTI! 🎓

Has pasado de no tener nada a tener un centro de operaciones automatizado, seguro y profesional.

Desde aquí, las posibilidades son infinitas. Podrías integrar esto con herramientas de orquestación (SOAR) o incluso empezar a crear tus propios reportes de inteligencia.

Para cerrar con broche de oro tu laboratorio en Kali Linux, vamos a integrar todo lo que hemos construido con un SIEM (Security Information and Event Management).

El SIEM es el "muro de pantallas" donde llega toda la actividad de tu red (logs de Windows, Linux, Firewall) y se cruza con la inteligencia que tienes en OpenTAXII. Si un usuario de tu red visita una IP que tu OpenTAXII marcó como maliciosa, el SIEM hará sonar la alarma.

En el mundo Open Source, el rey es Wazuh (basado en ELK: Elasticsearch, Logstash, Kibana).

1. ¿Cómo se conecta OpenTAXII con un SIEM?

Existen dos formas principales de alimentar a tu SIEM con la inteligencia que ya tienes:

Método	Cómo funciona	Ventaja
Pull (Extractor)	El SIEM consulta a OpenTAXII cada X minutos.	Muy estable y estándar.
Integración de Base de Datos	El SIEM lee directamente tu `data.db`.	Ultra rápido, sin latencia de red.
Lista de IoCs (Flat File)	Un script exporta una lista de IPs a un archivo de texto que el SIEM lee.	El método más compatible con Firewalls antiguos.

2. Configurar una "Lista Negra" para el SIEM

Vamos a crear un script que convierta tus datos de OpenTAXII en una Lista de Indicadores que cualquier SIEM (Wazuh, Splunk o ELK) pueda entender fácilmente.

Crea el archivo ~/opentaxii/export_to_siem.py:

Python
import sqlite3

def exportar_para_siem():
    conn = sqlite3.connect('/home/kali/opentaxii/data.db')
    cursor = conn.cursor()
    
    # Extraer solo las IPs de los bloques de contenido (simplificado)
    # Nota: En producción usarías una regex más robusta o el parser de STIX
    query = "SELECT content FROM opentaxii_content_blocks"
    cursor.execute(query)
    
    with open('/home/kali/opentaxii/siem_blacklist.txt', 'w') as f:
        for row in cursor.fetchall():
            content = row[0]
            # Aquí buscaríamos las IPs dentro del XML de STIX
            # Por ahora, simulamos la extracción
            f.write(f"{content}\n") 
            
    conn.close()
    print("[+] Lista de IoCs exportada para el SIEM.")

if __name__ == "__main__":
    exportar_para_siem()

3. El Flujo de Trabajo en tu Kali (Escenario Real)

Imagina este ataque:

Ataque: Un malware intenta conectar con la IP 1.2.3.4.
Detección: Tu Wazuh (SIEM) ve esa conexión en los logs de tu Kali.
Cotejo: El SIEM mira tu archivo siem_blacklist.txt (generado desde OpenTAXII).
Alerta: ¡Coincidencia! El SIEM genera una alerta de alta prioridad: "Conexión detectada a IP de C2 conocida".

4. ¿Qué SIEM deberías instalar en Kali?

Si quieres llevar este laboratorio al nivel máximo, te recomiendo instalar Wazuh. Es muy potente y se lleva de maravilla con Python.

Comando de instalación rápida (Docker):

Bash

curl -sSL https://packages.wazuh.com/4.x/wazuh-install.sh | sudo bash -s -- --stack

Resumen de tu Ecosistema de Ciberdefensa:

MISP: Inteligencia histórica y colaborativa.
OpenTAXII: Distribuidor oficial de amenazas (HTTPS/SSL).
Dashboard: Tu vista ejecutiva.
SIEM (Wazuh): Donde ocurre la detección real en tiempo real.
Alertas Email: Tu aviso proactivo.

Configurar una regla en el SIEM (Wazuh) para que reaccione específicamente a los datos de tu OpenTAXII es el paso final para tener un centro de operaciones (SOC) automatizado.

Para que esto funcione, usaremos una técnica llamada Cotejo de CDB (Constant DataBase). Wazuh es increíblemente rápido comparando logs contra listas de miles de IPs maliciosas.

1. Preparar la lista de IPs para el SIEM

Wazuh necesita que la lista de IPs tenga un formato específico: IP:Descripción. Vamos a modificar ligeramente tu script de exportación para que genere este archivo.

Actualiza tu archivo ~/opentaxii/export_to_siem.py:

Python
import sqlite3
import re

def exportar_para_wazuh():
    conn = sqlite3.connect('/home/kali/opentaxii/data.db')
    cursor = conn.cursor()
    cursor.execute("SELECT content FROM opentaxii_content_blocks")
    
    # Regex simple para extraer IPs del XML de STIX
    with open('/var/ossec/etc/lists/blacklist_taxii', 'w') as f:
        for row in cursor.fetchall():
            ips = re.findall(r'<Address_Value>(.*?)</Address_Value>', row[0])
            for ip in ips:
                f.write(f"{ip}:Amenaza_OpenTAXII\n")
    
    conn.close()
    print("[+] Lista exportada a /var/ossec/etc/lists/blacklist_taxii")

if __name__ == "__main__":
    exportar_para_wazuh()

2. Configurar la Regla en Wazuh

Ahora debemos decirle a Wazuh: "Si ves una IP de esta lista en cualquier log, genera una alerta de nivel 10 (Alta)".

Registra la lista en el archivo de configuración de Wazuh (/var/ossec/etc/ossec.conf):
XML
```
<ruleset>
  <list>etc/lists/blacklist_taxii</list>
</ruleset>
```

Crea la Regla Personalizada en /var/ossec/etc/rules/local_rules.xml:

XML
<group name="attack,opentaxii,">
  <rule id="100001" level="10">
    <list field="srcip" lookup="address_match_key">etc/lists/blacklist_taxii</list>
    <description>🚨 ALERTA: Conexión detectada desde IP maliciosa en OpenTAXII</description>
    <mitre>
      <id>T1071</id>
    </mitre>
  </rule>
</group>

3. Aplicar y Reiniciar

Para que Wazuh cargue la lista y la nueva regla:

Bash

# Compilar la lista (formato .cdb)
sudo /var/ossec/bin/util-lists-make

# Reiniciar el manager
sudo systemctl restart wazuh-manager

4. El Resultado Final: Alerta Visual y Sonora

Cuando un log (de Apache, de SSH o de tu Firewall) contenga una IP que esté en tu OpenTAXII, verás esto en el Dashboard de Wazuh:

Color Rojo: Indica una alerta de nivel 10.
Descripción: "ALERTA: Conexión detectada desde IP maliciosa en OpenTAXII".
Contexto: Verás exactamente qué usuario o proceso intentó comunicarse con esa IP.

Resumen de tu Poderosa Defensa 🛡️

MISP: Alimenta la inteligencia.
OpenTAXII: La distribuye de forma segura.
Script de Exportación: Traduce la inteligencia para el SIEM.
Wazuh: Vigila tu Kali en tiempo real y dispara la alarma si hay un "match".

Un Playbook (o Plan de Respuesta a Incidentes) es el conjunto de instrucciones que un analista de seguridad debe seguir cuando suena la alarma. En tu caso, cuando Wazuh detecta una IP de OpenTAXII, no basta con saber que ocurrió; hay que actuar.

Aquí tienes tu Playbook de Respuesta ante Indicadores de OpenTAXII:

📋 Playbook: Detección de IoC de Red (TAXII-001)

1. Fase de Identificación (¿Es real?)

Cuando salte la alerta de nivel 10 en Wazuh:

Verificar el origen: ¿Qué máquina de tu red intentó la conexión? (Campo agent.name en Wazuh).
Verificar el proceso: ¿Fue un navegador web, un script de Python o un proceso desconocido?
Consultar OpenTAXII: Busca la IP en tu Dashboard de Streamlit para ver de qué colección vino (ej. URLhaus o DigitalSide).

2. Fase de Contención (Parar el golpe)

Si confirmas que la conexión es sospechosa:

Aislamiento de Red: Bloquea la comunicación con esa IP inmediatamente en el firewall perimetral.

Bash

# Ejemplo rápido en el host afectado (si es Linux)
sudo iptables -A OUTPUT -d [IP_MALICIOSA] -j DROP

Aislamiento del Host: Si el proceso parece un malware activo, desconecta la máquina de la red para evitar que el ataque se propague (movimiento lateral).

3. Fase de Investigación (Análisis Forense)

Ahora que el peligro está pausado, investigamos en tu Kali:

Cruzar con MISP: Entra en tu instancia de MISP y busca la IP. Mira si está relacionada con algún Threat Actor específico o si hay muestras de malware asociadas.
Revisar Logs: Mira los logs previos a la alerta. ¿Hubo un correo de phishing antes? ¿Se descargó un archivo extraño?

4. Fase de Erradicación y Recuperación

Limpieza: Elimina el proceso malicioso o formatea la máquina afectada si es necesario.
Cambio de Credenciales: Si la IP maliciosa era un Panel de Control (C2), asume que las contraseñas de esa máquina han sido robadas y cámbialas todas.

5. Fase de Lecciones Aprendidas (Mejora del Sistema)

Ajustar OpenTAXII: Si la alerta fue un Falso Positivo (una IP legítima marcada como mala), añádela a una "Whitelist" en tu script de exportación para que no vuelva a sonar.
Retroalimentación: Si descubriste algo nuevo sobre el ataque, añádelo a tu MISP para que otros analistas (o tú mismo en el futuro) se beneficien.

🛠️ Tu "Kit de Supervivencia" en Kali

Para ejecutar este playbook, siempre ten a mano estos comandos:

Ver alertas en tiempo real: tail -f /var/ossec/logs/alerts/alerts.log | grep "OpenTAXII"
Ver quién está conectado a esa IP: sudo netstat -antp | grep [IP_MALICIOSA]
Ver el Dashboard: Accede a tu puerto 8501.

¿Qué te gustaría hacer para finalizar tu formación?

Has pasado de instalar un software a gestionar un Ciclo de Vida de Inteligencia y Respuesta completo. Es un logro impresionante para un entorno en Kali.