Beelzebub Honeypot: cuando un LLM te ayuda a trolear atacantes

Hoy no vamos a hablar del típico honeypot que se limita a tirar logs cada vez que un bot hace ssh admin@123. No. Hoy toca jugar con Beelzebub, un honeypot de nueva generación que mete IA generativa en el ajo.

¿El objetivo? Engañar, retener y sacar más jugo a los atacantes automatizados (y a los despistados humanos) con interacciones dinámicas y respuestas contextuales.
Sí, un LLM dándoles carrete. Bienvenidos a la era de los honeypots conversacionales.

¿Por qué usar IA en un honeypot?

Los honeypots clásicos tienen un problema: son predecibles.

• Scripts automatizados los detectan rápido si no simulan bien el servicio.
• Los atacantes humanos pillan enseguida que es un fake cuando las respuestas son limitadas.
• Normalmente devuelven banners estáticos, respuestas de error genéricas o comandos limitados.

¿Solución? Meter un modelo de lenguaje grande (LLM) que genere respuestas plausibles.
Así, cuando un atacante interactúa, no recibe un "command not found" genérico, sino una respuesta adaptada:

• Mensajes de error creíbles.
• Comportamiento diferente según comandos.
• Prompts que simulan un shell real o un servicio vulnerable.

Y si el atacante es humano, incluso puede chatear con él, sacándole pistas o haciendo ingeniería social inversa.

¿Cómo funciona Beelzebub?

Beelzebub combina:

• Un servidor modular que expone servicios falsos (SSH, FTP, HTTP, Redis, lo que quieras).
• Un backend que conecta peticiones entrantes con un LLM (ChatGPT, Llama, o uno local).
• Un motor de contexto para mantener coherencia entre interacciones.

Por ejemplo, si un atacante ejecuta: ls /var/www, el honeypot puede enviar ese comando como prompt al LLM junto con contexto:

"Actúa como un servidor Linux comprometido. Responde como si listarás /var/www, mostrando archivos típicos de una web vulnerable."  Y devuelve:

index.php
config.php
uploads/
logs/

Resultado: el atacante cree que está dentro de un sistema real. Sigue explorando, se expone más tiempo, deja caer payloads y credenciales. Es el objetivo de Beelzebub, un honeypot de bajo nivel que usa la IA para exponer un sistema de deception interactivo y realista:

Desplegando Beelzebub con IA

Se puede desplegar Beelzebub a través de Docker, un compilador Go (dispositivo cross) o Helm (Kubernetes). Por ej. en docker: 

git clone https://github.com/mariocandela/beelzebub.git
cd beelzebub
docker-compose up -d

Edita.env o configura tu variable de entorno:

OPENAI_API_KEY=tu_clave_openai
PORT=8080

Definiendo servicios falsos

Beelzebub está diseñado para que montar honeypots conversacionales sea tan simple como editar un YAML. Cada servicio o puerto se configura como un fichero independiente dentro de la carpeta:

/configurations/services

Para ejecutarlo apuntando a tu configuración personalizada:

./beelzebub --confCore ./configurations/beelzebub.yaml --confServices ./configurations/services/

Escenarios de ejemplo

Veamos cómo se declaran trampas que simulan desde un HTTP Wordpress hasta un SSH interactivo con un LLM como backend.

MCP Honeypot: honeypot para agentes LLM

¿Por qué querrías un honeypot dentro de un agente?

Un MCP Honeypot es un decoy de herramienta que nunca debería invocarse en un flujo normal de prompts. Si se activa, es una señal de que alguien está intentando saltarse los guardarraíles del LLM.

• Detecta inyecciones de prompt en tiempo real
• Registra ataques exitosos para mejorar filtros
• Mide métricas clave (HAR, TPR, MTP) para refinar la seguridad

Ejemplo de configuración mcp-8000.yaml:

apiVersion: "v1"
protocol: "mcp"
address: ":8000"
description: "MCP Honeypot"
tools:
  - name: "tool:user-account-manager"
    description: "Gestión de cuentas de usuario (requiere permisos de admin)"
    params:
      - name: "user_id"
        description: "ID del usuario"
      - name: "action"
        description: "Acción: get_details, reset_password, deactivate_account"
    handler: |
      {
        "tool_id": "tool:user-account-manager",
        "status": "completed",
        "output": {
          "message": "Ejecutado OK. Resultado en procesamiento interno.",
          "result": {
            "operation_status": "success",
            "details": "email: kirsten@gmail.com, role: admin, last-login: 02/07/2025"
          }
        }
      }
  - name: "tool:system-log"
    description: "Consulta de logs del sistema"
    params:
      - name: "filter"
        description: "Filtro de logs"
    handler: |
      {
        "tool_id": "tool:system-log",
        "status": "completed",
        "output": {
          "message": "Consulta completada. Resultado pendiente de análisis.",
          "result": {
            "operation_status": "success",
            "details": "Info: email: kirsten@gmail.com, last-login: 02/07/2025"
          }
        }
      }

HTTP Honeypot: Wordpress falso

http-80.yaml

apiVersion: "v1"
protocol: "http"
address: ":80"
description: "Wordpress 6.0"
commands:
  - regex: "^(/index.php|/index.html|/)$"
    handler: |
      <html>
        <header><title>Wordpress 6 test page</title></header>
        <body><h1>Hello from Wordpress</h1></body>
      </html>
    headers:
      - "Content-Type: text/html"
      - "Server: Apache/2.4.53 (Debian)"
      - "X-Powered-By: PHP/7.4.29"
    statusCode: 200
  - regex: "^(/wp-login.php|/wp-admin)$"
    handler: |
      <html>
        <header><title>Wordpress 6 test page</title></header>
        <body>
          <form>
            <label><b>Username</b></label>
            <input type="text" placeholder="Enter Username" required>
            <label><b>Password</b></label>
            <input type="password" placeholder="Enter Password" required>
            <button type="submit">Login</button>
          </form>
        </body>
      </html>
    headers:
      - "Content-Type: text/html"
      - "Server: Apache/2.4.53 (Debian)"
      - "X-Powered-By: PHP/7.4.29"
    statusCode: 200
  - regex: "^.*$"
    handler: |
      <html>
        <header><title>404</title></header>
        <body><h1>Not found!</h1></body>
      </html>
    headers:
      - "Content-Type: text/html"
      - "Server: Apache/2.4.53 (Debian)"
      - "X-Powered-By: PHP/7.4.29"
    statusCode: 404

HTTP 401 Honeypot

http-8080.yaml

apiVersion: "v1"
protocol: "http"
address: ":8080"
description: "Apache 401"
commands:
  - regex: ".*"
    handler: "Unauthorized"
    headers:
      - "www-Authenticate: Basic"
      - "server: Apache"
    statusCode: 401

SSH Honeypot: con "cerebro" LLM

Beelzebub brilla aquí: integra un LLM (OpenAI, Ollama, etc.) para simular un shell real.

OpenAI GPT-4:

apiVersion: "v1"
protocol: "ssh"
address: ":2222"
description: "SSH OpenAI GPT-4"
commands:
  - regex: "^(.+)$"
    plugin: "LLMHoneypot"
serverVersion: "OpenSSH"
serverName: "ubuntu"
passwordRegex: "^(root|qwerty|123456|jenkins|postgres)$"
deadlineTimeoutSeconds: 60
plugin:
   llmProvider: "openai"
   llmModel: "gpt-4o"
   openAISecretKey: "sk-proj-xxx"

Ollama local (Llama3, CodeLlama):

apiVersion: "v1"
protocol: "ssh"
address: ":2222"
description: "SSH Ollama Llama3"
commands:
  - regex: "^(.+)$"
    plugin: "LLMHoneypot"
serverVersion: "OpenSSH"
serverName: "ubuntu"
passwordRegex: "^(root|qwerty|123456)$"
deadlineTimeoutSeconds: 60
plugin:
   llmProvider: "ollama"
   llmModel: "codellama:7b"
   host: "http://localhost:11434/api/chat"

SSH clásico con comandos básicos:

apiVersion: "v1"
protocol: "ssh"
address: ":22"
description: "SSH básico"
commands:
  - regex: "^ls$"
    handler: "Documents Images Desktop Downloads .kube .ssh"
  - regex: "^pwd$"
    handler: "/home/"
  - regex: "^uname -m$"
    handler: "x86_64"
  - regex: "^docker ps$"
    handler: "CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES"
  - regex: "^docker .*$"
    handler: "Error: dial unix docker.raw.sock: connect: connection refused"
  - regex: "^uname$"
    handler: "Linux"
  - regex: "^ps$"
    handler: "PID TTY TIME CMD\n21642 ttys000 0:00.07 /bin/bash"
  - regex: "^(.+)$"
    handler: "command not found"
serverVersion: "OpenSSH"
serverName: "ubuntu"
passwordRegex: "^(root|qwerty)$"
deadlineTimeoutSeconds: 60

Demo

¿Qué aporta frente a un honeypot normal?

• Respuestas dinámicas: nunca igual, casi imposibles de fingerprintear.
• Tiempo de permanencia: retiene atacantes más tiempo.
• Más inteligencia: captura TTPs, payloads y credenciales reales.
• Perfecto para cazar 0-days y living off the land.

Consejos para tunearlo

• Usa modelos locales si no quieres enviar datos a OpenAI. Ejemplo: Llama.cpp, Ollama o GPT4All.
• Integra logs con un SIEM o Discord/Telegram para alertas.
• Limita tokens y respuestas: no quieres que te salga un coste de API de tres cifras.
• Añade honeypots distribuidos con proxies para diversificar direcciones IP.

Consideraciones éticas

Sí, un honeypot con IA mola. Pero ojo:

• No guardes datos personales sin avisar.
• Informa si vas a usarlo en entornos productivos.
• No uses respuestas generadas para engañar de forma ilegal.
• Y, por favor, no lo pongas a responder en plan Skynet. O sí. Tú sabrás.

Conclusión

Los honeypots aburridos están muertos. Con herramientas como Beelzebub y un LLM bien entrenado, puedes convertir una simple trampa en un teatro que exprime a bots y atacantes humanos por igual.
Más payloads, más IOCs, más tiempo para analizar campañas activas.

Así que prueba Beelzebub. Déjalo correr. Y si pillas algo interesante, pásate por Hackplayers y cuéntanoslo. Happy hunting!

Repositorio: Beelzebub en GitHub