Livewire Honeypot

Un honeypot de alta interacción que se hace pasar por una aplicación vulnerable de Laravel/Livewire. Captura intentos de explotación dirigidos a CVEs conocidos de Livewire, almacena archivos maliciosos subidos (webshells) y cargas útiles de ejecución remota de código (RCE) con deduplicación SHA-256 y, opcionalmente, los ejecuta en un contenedor Docker aislado para extraer indicadores de compromiso (IOCs) — URLs, IPs y dominios con los que el malware intenta contactar.

El sistema se ejecuta como dos procesos separados por seguridad: un servidor web que captura las cargas útiles (sin acceso a Docker) y un trabajador de sandbox que las analiza en contenedores aislados.

Cómo funciona

Atacante → Nginx → FastAPI → SQLite ← Trabajador de sandbox (Docker)
                   (captura)               (sondea trabajos, escribe IOCs)

1. Fachada — Sirve páginas realistas de inicio de sesión/registro de Laravel con atributos wire: de Livewire, tokens XSRF y cabeceras X-Powered-By: PHP/8.3.12. Los escáneres automatizados ven lo que parece una aplicación vulnerable real.

2. Captura — Cada petición HTTP se registra en SQLite (IP, cabeceras, hash del cuerpo, timestamp) mediante una capa middleware ASGI, de forma transparente, antes de cualquier enrutamiento.

3. Señuelos — Los endpoints de Livewire aceptan subidas de archivos y mensajes de componentes como lo haría el framework real. Las cargas útiles se clasifican (código PHP, objetos serializados, comandos de shell) y se almacenan con deduplicación SHA-256. Cada carga útil interesante crea un trabajo duradero en la cola sandbox_jobs.

4. Sandbox — Un proceso trabajador independiente sondea trabajos pendientes y ejecuta cada carga útil en un contenedor Docker efímero (sistema de archivos de solo lectura, sin red, cap_drop=ALL). Un shim LD_PRELOAD intercepta las llamadas de red de libc para registrar intentos de comunicación C2 (comando y control). El analizador extrae los IOCs y puntúa posibles endpoints C2 mediante heurísticas.

CVEs objetivo

Un señuelo comodín *.php también captura sondeos posteriores a la explotación para nombres de webshell comunes (por ejemplo, accesson.php, wp-login.php, admin.php).

Inicio rápido

Requisitos: Python 3.11+ y uv.

git clone https://github.com/HelgeSverre/livewire-honeypot.git
cd livewire-honeypot

# Instalar dependencias
uv sync

# Iniciar el servidor web (solo captura, no necesita Docker)
DATA_DIR=./data uv run uvicorn honeypot.main:app --reload --port 8000

# En una segunda terminal — iniciar el trabajador de sandbox (requiere Docker)
DATA_DIR=./data uv run python -m honeypot.worker

# Ejecutar pruebas
uv run pytest tests/ -v

El servidor web funciona de forma independiente — captura y almacena todo incluso sin el trabajador de sandbox en ejecución. Inicia el trabajador cuando quieras análisis automatizado de cargas útiles.

Nota: El directorio src/ está en el path de Python a través de pyproject.toml (src-layout), por lo que honeypot.main:app se asigna a src/honeypot/main.py.

Despliegue

Inicio rápido: DigitalOcean (o cualquier VPS con Ubuntu 24.04)

Necesitarás:

• Una cuenta de DigitalOcean (o cualquier proveedor que te dé acceso root a Ubuntu 24.04).
• Un dominio que controles. TLS hace que el señuelo parezca real para los escáneres, y en cuanto certbot emite un certificado, tu nombre de host aparece en los registros de transparencia de certificados — es lo que Shodan, Censys y la mayoría de los kits de explotación masiva usan para descubrir nuevos objetivos en cuestión de horas.

El despliegue completo es un solo comando una vez que la VPS existe. El script maneja cada paso desde "droplet limpio" a "servicio funcionando con TLS" — paquetes apt, usuarios y grupos, entorno virtual de Python, imagen de sandbox, nginx, certbot y reglas de firewall.

# 1. Crear un droplet de $6/mes (Ubuntu 24.04, 1 GB de RAM es suficiente).
#    En DigitalOcean:
doctl compute droplet create veritron-honeypot \
    --size s-1vcpu-1gb \
    --image ubuntu-24-04-x64 \
    --region fra1 \
    --ssh-keys "$(doctl compute ssh-key list --format ID --no-header | head -1)" \
    --wait

# 2. Apuntar el registro A de tu dominio a la IP del droplet.
#    Esperar a que DNS resuelva antes de continuar.
dig +short tu-dominio.ejemplo   # debería devolver la IP del droplet

# 3. Copiar el proyecto al droplet.
rsync -az --exclude='.git' --exclude='.venv' --exclude='data' \
    ./ root@<ip-del-droplet>:/opt/honeypot/

# 4. Ejecutar el script de arranque. Pasar tu dominio habilita TLS mediante certbot.
ssh root@<ip-del-droplet> 'cd /opt/honeypot && [email protected] \
    bash deploy/setup.sh tu-dominio.ejemplo'

Eso es todo. El honeypot ahora sirve una página de inicio de sesión falsa de Laravel/Livewire a través de HTTPS, capturando cada petición en SQLite, y listo para analizar cargas útiles en el sandbox Docker.

Lo que hace el script de arranque

deploy/setup.sh es idempotente — volver a ejecutarlo es seguro. En orden:

1. Espera a que cloud-init / unattended-upgrades liberen el bloqueo de dpkg (los droplets nuevos lo mantienen durante 1-3 minutos tras el arranque).
2. Instala nginx, certbot, docker.io, Python 3.12 del sistema, sqlite3.
3. Instala uv (Astral) en /root/.local/bin.
4. Crea los usuarios de servicio honeypot (web) y sandbox (trabajador), y el grupo compartido honeypot-data.
5. Ejecuta uv sync --python /usr/bin/python3.12. Usamos deliberadamente el Python instalado por apt en lugar del intérprete incluido por uv — el Python de uv vive en /root/.local/share/uv/, que un usuario de servicio sin privilegios no puede recorrer, y obtendrías un confuso status=203/EXEC de systemd si dejas que uv elija el intérprete.
6. Crea /var/honeypot/ con bit setgid y propiedad de grupo compartida, para que ambos servicios puedan leer las escrituras del otro.
7. Instala los archivos de unidad systemd y reescribe el ExecStart del trabajador para usar el daemon Docker del sistema (la unidad incluida asume Docker rootless, que es más difícil de configurar).
8. Construye la imagen del contenedor sandbox (docker build -t honeypot-sandbox sandbox/).
9. Escribe la configuración del sitio nginx y agrega la directiva en (debe estar en el bloque , no en ).

Configuración manual

Si quieres realizar cada paso tú mismo en lugar de ejecutar setup.sh, el historial de comandos equivalente está en deploy/setup.sh como etapas comentadas.

Arquitectura de servicios

Ambos servicios comparten /var/honeypot/ para la base de datos SQLite y el almacenamiento de cargas útiles. El proceso web no tiene acceso al socket de Docker, por lo que incluso si se ve comprometido mediante tráfico de atacantes, no puede crear contenedores en el host.

Operaciones

# Ver logs
journalctl -u honeypot -f
journalctl -u honeypot-worker -f

# Reiniciar servicios
systemctl restart honeypot honeypot-worker

# Actualizar
cd /opt/honeypot && git pull && uv sync
docker build -t honeypot-sandbox sandbox/
systemctl restart honeypot honeypot-worker

Configuración

Todos los ajustes se controlan mediante variables de entorno (definidas en los archivos de unidad systemd o exportadas antes de ejecutar):

Consultar datos capturados

Todos los datos residen en una única base de datos SQLite (por defecto: /var/honeypot/captures.db).

# Peticiones recientes
sqlite3 /var/honeypot/captures.db \
  "SELECT timestamp, source_ip, method, path, matched_trap
   FROM requests ORDER BY id DESC LIMIT 20;"

# Cargas útiles únicas por frecuencia
sqlite3 /var/honeypot/captures.db \
  "SELECT sha256, filename, payload_type, times_seen, sandbox_status
   FROM payloads ORDER BY times_seen DESC;"

# IPs de atacantes principales
sqlite3 /var/honeypot/captures.db \
  "SELECT ip, total_requests, first_seen, last_seen
   FROM attackers ORDER BY total_requests DESC LIMIT 10;"

# Resultados del sandbox con IOCs extraídos (JSON)
sqlite3 /var/honeypot/captures.db \
  "SELECT payload_id, exit_code, duration_seconds, c2_urls_found, iocs
   FROM sandbox_runs ORDER BY id DESC LIMIT 5;"

# Trabajos de sandbox pendientes
sqlite3 /var/honeypot/captures.db \
  "SELECT id, payload_sha256, status, created_at
   FROM sandbox_jobs ORDER BY id DESC LIMIT 10;"

Los datos de IOC en sandbox_runs.iocs se almacenan como JSON con las claves: domains, ips, emails, urls, hashes. Extrae y alimenta tu plataforma de inteligencia de amenazas (MISP, OpenCTI, etc.) según sea necesario.

Estructura del proyecto

src/honeypot/
  main.py              # Aplicación web FastAPI (solo captura, sin Docker)
  worker.py            # Trabajador de sandbox independiente (sondea SQLite, necesita Docker)
  config.py            # Configuración desde variables de entorno
  capture/
    database.py        # SQLite asíncrono — peticiones, cargas útiles, cola sandbox_jobs
    logger.py          # Middleware ASGI — registra cada petición
    payloads.py        # Almacenamiento con deduplicación SHA-256 + clasificación de cargas útiles
  facade/
    routes.py          # Páginas con huella de Laravel (inicio de sesión, registro, etc.)
    templates/         # HTML Jinja2 con atributos wire: de Livewire
    static/            # livewire.js falso (huella v3.5.1)
  traps/
    livewire.py        # POST /livewire/message, /upload-file, /preview-file
    php_catchall.py    # Captura general para sondeos *.php
  sandbox/
    orchestrator.py    # Ciclo de vida del contenedor Docker + endurecimiento
    analyzer.py        # Análisis de artefactos + extracción de IOC + puntuación C2
deploy/
  nginx.conf           # Proxy inverso con limitación de tasa
  honeypot.service     # Unidad systemd (web)
  honeypot-worker.service  # Unidad systemd (trabajador de sandbox)
  setup.sh             # Script de arranque para VPS
sandbox/
  Dockerfile           # Imagen del contenedor sandbox (PHP 8.3 + herramientas de atacante)
  entrypoint.sh        # Punto de entrada del contenedor con shim de red LD_PRELOAD

Aviso legal

Esta es una herramienta de investigación para recolectar muestras de malware y observar el comportamiento de atacantes en infraestructura que posees. No es un producto de seguridad en producción. Despliégalo únicamente en sistemas que controles, y ten en cuenta que capturar y ejecutar cargas útiles de atacantes puede tener implicaciones legales en tu jurisdicción. La base de datos SQLite y los archivos de cargas útiles crecen sin límite — monitorea el uso del disco e implementa políticas de retención según sea necesario.

Contribuciones

Las incidencias y solicitudes de extracción son bienvenidas.

Licencia

MIT