Volver a actualizaciones
Nuevo releaseAug 21, 2026

Krawl v2.3.0

Krawl es un servidor de decepción web personalizable, liviano y nativo de la nube, y un anti-crawler que crea aplicaciones web falsas con vulnerabilidades de bajo nivel utilizando datos señuelo generados aleatoriamente y realistas, y plantillas HTML generadas por IA.

Compartir

Krawl

Un servidor honeypot web moderno y personalizable, diseñado para detectar y rastrear actividad maliciosa de atacantes y rastreadores web mediante páginas web engañosas, credenciales falsas y tokens canary.

Tabla de contenidos

Demo

Consejo: rastrea las rutas de robots.txt para diversión adicional

URL de Krawl: http://demo.krawlme.com

Ver el panel http://demo.krawlme.com/das_dashboard

¿Qué es Krawl?

Krawl es un servidor de engaño nativo de la nube diseñado para detectar, retrasar y analizar atacantes maliciosos, rastreadores web y escáneres automatizados.

Crea aplicaciones web falsas y realistas llenas de objetivos fáciles, como paneles de administración, archivos de configuración y credenciales falsas expuestas, para atraer e identificar actividad sospechosa.

panel

Al desperdiciar los recursos de los atacantes, Krawl ayuda a distinguir claramente el comportamiento malicioso de los rastreadores legítimos.

Sus características incluyen:

  • Páginas de engaño generadas por IA: Deja que los atacantes te ayuden a generar tu superficie de ataque falsa y vulnerable
  • Páginas trampa para arañas: Enlaces aleatorios infinitos para desperdiciar recursos de los rastreadores, basados en el proyecto spidertrap
  • Páginas de inicio de sesión falsas: WordPress, phpMyAdmin, paneles de administración
  • Rutas honeypot: Anunciadas en robots.txt para atrapar escáneres
  • Credenciales falsas: Nombres de usuario, contraseñas y claves de API de apariencia realista
  • Integración de Canary Token: Activación de alertas externas
  • Cabeceras de servidor aleatorias: Confundir ataques según la cabecera y la versión del servidor
  • Panel en tiempo real: Monitorea la actividad sospechosa
  • Listas de palabras personalizables: Configuración sencilla basada en JSON
  • Inyección de errores aleatorios: Imita el comportamiento real del servidor

Puedes exponer fácilmente Krawl junto a tus otros servicios para protegerlos de rastreadores web y usuarios malintencionados mediante un proxy inverso. Para más detalles, consulta la documentación de proxy inverso.

caso de uso

Panel de Krawl

Krawl proporciona un panel completo, accesible en una ruta secreta aleatoria generada al inicio o en una ruta personalizada configurada mediante KRAWL_DASHBOARD_SECRET_PATH. Esto mantiene el panel oculto de los atacantes que escanean tu honeypot.

El panel está organizado en seis pestañas:

  • Resumen: vista de alto nivel de la actividad de ataques: un mapa interactivo de orígenes de IP, solicitudes sospechosas recientes y las principales IP, User-Agents y rutas.

geoip

  • Ataques: desglose detallado de credenciales capturadas, activaciones de honeypot y tipos de ataque detectados (SQLi, XSS, path traversal, etc.) con gráficos y tablas.

attack_types

  • Información de IP: vista forense en profundidad de una IP seleccionada: geolocalización, información de ISP/ASN, indicadores de reputación, línea temporal de comportamiento, distribución de tipos de ataque e historial completo de accesos.

ipinsight

Además, tras autenticarse con la contraseña del panel, dos pestañas protegidas quedan disponibles:

  • IPs rastreadas: mantén una lista de seguimiento de direcciones IP que deseas monitorear con el tiempo.
  • Lista de bloqueo de IP: gestiona los bloqueos de IP, consulta los atacantes detectados y exporta la lista de bloqueo en formato raw o IPTables.
  • Engaño: administra las páginas generadas por IA, expórtalas o importa otras nuevas.

Para más detalles, consulta la documentación del panel.

Modos de despliegue

Krawl admite dos modos de despliegue, controlados por el ajuste mode en config.yaml o por la variable de entorno KRAWL_MODE.

StandaloneEscalable
Base de datosSQLite (modo WAL)PostgreSQL
CachéDict de Python en memoriaRedis (TTL multinivel)
Réplicas1 (instancia única)1+ (escalado horizontal)
Dependencias externasNingunaPostgreSQL + Redis
Ideal paraDev, homelabs, <500k peticionesProducción, HA, >500k peticiones

Standalone: ideal para entornos de desarrollo u homelabs con volúmenes bajos de peticiones. No se necesita configuración adicional; solo ejecuta Krawl y funcionará.

  • Despliegue en un solo contenedor sin dependencias externas
  • Menor uso de RAM y recursos

Escalable: diseñado para entornos de producción o honeypots de alto tráfico. El chart de Helm usa este modo por defecto.

  • Panel más rápido y con mayor capacidad de respuesta gracias al caché multinivel de Redis
  • Menor E/S de disco gracias a Redis como caché de acceso rápido frente a PostgreSQL
  • El escalado horizontal aumenta la cantidad de réplicas de Krawl detrás de un balanceador de carga

Para obtener una configuración detallada, ejemplos de Docker Compose, configuración de Kubernetes/Helm e instrucciones de migración paso a paso, consulta la documentación de Modos de despliegue.

Lista de bloqueo de Krawl

Krawl mantiene una banlist.txt actualizada periódicamente con direcciones IP de atacantes que activaron sus trampas honeypot. La lista de bloqueo se publica semanalmente y está disponible para su descarga, lo que ayuda a la comunidad a bloquear preventivamente a actores maliciosos conocidos incluso sin usar Krawl.

La lista de bloqueo también se puede obtener directamente desde: https://demo.krawlme.com/das_dashboard/api/export-ips?categories=attacker&fwtype=raw.

Compartir listas de bloqueo entre instancias

Las instancias de Krawl pueden federar sus listas de bloqueo: cada una puede publicar su propia lista en una ruta no autenticada y obtener listas de otras instancias (o cualquier lista de IP en texto plano). Las IP obtenidas se fusionan con las decisiones de bloqueo locales y se muestran en el panel.```yaml banlist:

Public, unauthenticated download path for this instance's banlist.

Supports the same ?categories= and ?fwtype= parameters as the main API.

Empty = disabled.

export_path: "/public_banlist.txt"

Upstream banlists to fetch and merge. Plain ".txt" lists work too.

sources: - "https://demo.krawlme.com/das_dashboard/api/export-ips?categories=attacker&fwtype=raw" - "https://krawl.example.com/public_banlist.txt"

refresh_interval: 3600 # seconds between fetches

## Inicio rápido

### Docker Run

Ejecuta Krawl en modo independiente con la última imagen:```bash
docker run -d \
  -p 5000:5000 \
  -e KRAWL_DASHBOARD_SECRET_PATH="/my-secret-dashboard" \
  -e KRAWL_DASHBOARD_PASSWORD="my-secret-password" \
  -v krawl-data:/app/data \
  --name krawl \
  ghcr.io/blessedrebus/krawl:latest

Accede al servidor en http://localhost:5000

Docker Compose

Crea un docker-compose.yaml con uno de los dos modos de implementación.

Standalone: solo el servidor Krawl con almacenamiento Sqlite:```yaml services: krawl: image: ghcr.io/blessedrebus/krawl:latest container_name: krawl-server ports: - "5000:5000" environment: - CONFIG_LOCATION=config.yaml # - KRAWL_DASHBOARD_PASSWORD=my-secret-password volumes: - ./config.yaml:/app/config.yaml:ro - krawl-data:/app/data restart: unless-stopped

volumes: krawl-data:

**Escalable**: con PostgreSQL y Redis:

> [!CAUTION]
> El ejemplo a continuación utiliza **contraseñas predeterminadas** (`krawl`/`krawl`). **Cámbielas antes de desplegar en producción.**```yaml
services:
  postgres:
    image: postgres:16-alpine
    environment:
      POSTGRES_DB: krawl
      POSTGRES_USER: krawl
      POSTGRES_PASSWORD: krawl
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U krawl -d krawl"]
      interval: 10s
      timeout: 5s
      retries: 5

  redis:
    image: redis:7-alpine
    volumes:
      - redis_data:/data
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

  krawl:
    image: ghcr.io/blessedrebus/krawl:latest
    container_name: krawl-server
    ports:
      - "5000:5000"
    environment:
      - CONFIG_LOCATION=config.yaml
      - KRAWL_MODE=scalable
      - KRAWL_POSTGRES_HOST=postgres
      - KRAWL_POSTGRES_PORT=5432
      - KRAWL_POSTGRES_USER=krawl
      - KRAWL_POSTGRES_PASSWORD=krawl
      - KRAWL_POSTGRES_DATABASE=krawl
      - KRAWL_REDIS_HOST=redis
      - KRAWL_REDIS_PORT=6379
      # - KRAWL_DASHBOARD_PASSWORD=my-secret-password
    volumes:
      - ./config.yaml:/app/config.yaml:ro
    restart: unless-stopped
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy

volumes:
  postgres_data:
  redis_data:

Para desplegar, solo ejecuta```bash docker compose up -d

Los archivos compose listos para producción también están disponibles en el directorio [`docker/`](https://github.com/blessedrebus/krawl/blob/HEAD/docker/). Para **desarrollo** (compilaciones desde el código fuente con recarga en caliente), usa los archivos compose en [`docker/dev/`](https://github.com/blessedrebus/krawl/blob/HEAD/docker/dev/).

Para más detalles sobre ambos modos, consulta [Modos de despliegue](https://github.com/blessedrebus/krawl/blob/HEAD/docs/deployment-modes.md).

### Kubernetes
**Krawl también está disponible de forma nativa en Kubernetes**. La instalación se puede realizar [mediante el manifiesto](https://github.com/blessedrebus/krawl/blob/HEAD/kubernetes/README.md) o [usando el chart de Helm](https://github.com/blessedrebus/krawl/blob/HEAD/helm/README.md).

El chart de Helm **está configurado por defecto en modo escalable** con PostgreSQL y Redis integrados:```bash
helm install krawl oci://ghcr.io/blessedrebus/krawl-chart --version 2.3.0 \
  -n krawl-system --create-namespace \
  --set postgres.password=your-password \
  --set redis.password=your-redis-password \
  --set dashboardPassword=your-dashboard-password \
  --set config.dashboard.secret_path=/my-secret-dashboard

Se proporcionan archivos de valores de ejemplo mínimos para ambos modos:

Consulte Modos de implementación y Documentación del chart para obtener la configuración completa y las instrucciones de migración.

Uvicorn (Python)

Ejecute Krawl directamente con Python 3.13+ y uvicorn para desarrollo o pruebas locales:```bash pip install -r requirements.txt uvicorn app:app --host 0.0.0.0 --port 5000 --app-dir src --no-server-header

Accede al servidor en `http://localhost:5000`


## Configuración
Krawl utiliza una **jerarquía de configuración** en la que **las variables de entorno tienen prioridad sobre el archivo de configuración**. Este enfoque se recomienda para despliegues con Docker y para una personalización rápida sin configuración previa.

### Configuración mediante config.yaml
Puedes utilizar el archivo [config.yaml](https://github.com/blessedrebus/krawl/blob/HEAD/config.yaml) para configuraciones avanzadas, como despliegues con Docker Compose o Helm chart.

### Configuración mediante variables de entorno

Todos los ajustes pueden proporcionarse como variables de entorno, que anulan `config.yaml`.
El nombre de la variable es `KRAWL_` más la ruta del ajuste en mayúsculas, por lo que `dashboard.password`
se convierte en `KRAWL_DASHBOARD_PASSWORD`.

<details>
<summary><b>Servidor y generación de enlaces</b> (12 variables)</summary>

Cómo se presenta Krawl y da forma al laberinto de páginas generadas.

| Variable de entorno | Descripción | Predeterminado |
|----------------------|-------------|---------|
| `CONFIG_LOCATION` | Ruta al archivo de configuración yaml | `config.yaml` |
| `KRAWL_PORT` | Puerto de escucha del servidor | `5000` |
| `KRAWL_DELAY` | Retraso de respuesta en milisegundos | `100` |
| `KRAWL_SERVER_HEADER` | Cabecera HTTP Server para engaño | `""` |
| `KRAWL_LINKS_LENGTH_RANGE` | Rango de longitud de enlaces como `min,max` | `5,15` |
| `KRAWL_LINKS_PER_PAGE_RANGE` | Enlaces por página como `min,max` | `10,15` |
| `KRAWL_CHAR_SPACE` | Caracteres utilizados para la generación de enlaces | `abcdefgh...` |
| `KRAWL_MAX_COUNTER` | Valor inicial del contador | `10` |
| `KRAWL_PROBABILITY_ERROR_CODES` | Probabilidad de códigos de error en la respuesta (0-100%) | `0` |
| `KRAWL_INFINITE_PAGES_FOR_MALICIOUS` | Servir páginas infinitas a IPs maliciosas | `true` |
| `KRAWL_MAX_PAGES_LIMIT` | Límite máximo de páginas para rastreadores | `250` |
| `KRAWL_BAN_DURATION_SECONDS` | Duración del baneo en segundos para IPs con limitación de velocidad | `600` |

</details>

<details>
<summary><b>Panel, métricas y registro</b> (8 variables)</summary>

Acceso al panel, precarga de caché, Prometheus y nivel de registro.

| Variable de entorno | Descripción | Predeterminado |
|----------------------|-------------|---------|
| `KRAWL_DASHBOARD_SECRET_PATH` | Ruta personalizada del panel | Generada automáticamente |
| `KRAWL_DASHBOARD_PASSWORD` | Contraseña para los paneles protegidos del dashboard | Generada automáticamente |
| `KRAWL_DASHBOARD_CACHE_WARMUP` | Precalcular los datos del panel cada 5 minutos para una carga instantánea de páginas | `true` |
| `KRAWL_DASHBOARD_WARMUP_PAGES` | Número de páginas a precalentar por panel de tabla | `10` |
| `KRAWL_DASHBOARD_WARMUP_AGGREGATION` | Precalcular las agregaciones completas de top_paths/top_ua para servir sin consultas | `false` |
| `KRAWL_DASHBOARD_TOP_N_MIN_COUNT` | Recuento mínimo de accesos para los paneles de rutas/agentes de usuario principales (ajustar a 1 para deshabilitar) | `5` |
| `KRAWL_METRICS_ENABLED` | Exponer métricas de Prometheus en `/<dashboard_path>/metrics` | `true` |
| `KRAWL_LOG_LEVEL` | Nivel de registro de la aplicación (`DEBUG`, `INFO`, `WARNING`, `ERROR`) | `INFO` |

</details>

<details>
<summary><b>Base de datos, retención y copias de seguridad</b> (6 variables)</summary>

Ubicación del almacenamiento, durante cuánto tiempo se conservan los datos y la tarea de volcado.

| Variable de entorno | Descripción | Predeterminado |
|----------------------|-------------|---------|
| `KRAWL_DATABASE_PATH` | Ubicación del archivo de base de datos | `data/krawl.db` |
| `KRAWL_DATABASE_PERSIST_SUSPICIOUS_ONLY` | Persistir solo las solicitudes sospechosas en el registro de accesos | `false` |
| `KRAWL_DATABASE_RETENTION_DAYS` | Días de retención de datos en la base de datos | `30` |
| `KRAWL_BACKUPS_PATH` | Ruta donde se guardan los volcados de la base de datos | `backups` |
| `KRAWL_BACKUPS_CRON` | Expresión cron para controlar la programación de la tarea de copia de seguridad | `*/30 * * * *` |
| `KRAWL_BACKUPS_ENABLED` | Booleano para habilitar la tarea de volcado de la base de datos | `true` |

</details>

<details>
<summary><b>Trampas: tarpit, páginas de engaño y canario</b> (6 variables)</summary>

Trampas opcionales y las páginas servidas a los atacantes.

| Variable de entorno | Descripción | Predeterminado |
|----------------------|-------------|---------|
| `KRAWL_TARPIT_ENABLED` | Atrapar agentes de IA con respuestas lentas y texto aleatorio | `false` |
| `KRAWL_TARPIT_DELAY_SECONDS` | Retraso adicional en segundos añadido por respuesta cuando el tarpit está activo | `5` |
| `KRAWL_DECEPTION_IMPORT_PAGES` | Importar automáticamente páginas de engaño desde `src/templates/deception/` al iniciar | `true` |
| `KRAWL_CUSTOM_TEMPLATE_PATH` | Ruta dentro del contenedor a una plantilla HTML personalizada. La plantilla debe incluir los marcadores de posición `{counter}` y `{content}`. | `/templates/custom_page.html` |
| `KRAWL_CANARY_TOKEN_URL` | URL externa del token canario | Ninguna |
| `KRAWL_CANARY_TOKEN_TRIES` | Solicitudes antes de mostrar el token canario | `10` |

</details>

<details>
<summary><b>Analizador de reputación de IP</b> (6 variables)</summary>

Umbrales que determinan cómo se clasifica una IP.

| Variable de entorno | Descripción | Predeterminado |
|----------------------|-------------|---------|
| `KRAWL_HTTP_RISKY_METHODS_THRESHOLD` | Umbral para la detección de métodos HTTP de riesgo | `0.1` |
| `KRAWL_VIOLATED_ROBOTS_THRESHOLD` | Umbral para violaciones de robots.txt | `0.1` |
| `KRAWL_UNEVEN_REQUEST_TIMING_THRESHOLD` | Umbral del coeficiente de variación para la sincronización de solicitudes | `0.5` |
| `KRAWL_UNEVEN_REQUEST_TIMING_TIME_WINDOW_SECONDS` | Ventana de tiempo para el análisis de sincronización de solicitudes en segundos | `300` |
| `KRAWL_USER_AGENTS_USED_THRESHOLD` | Umbral para detectar múltiples user agents | `2` |
| `KRAWL_ATTACK_URLS_THRESHOLD` | Umbral para la detección de URL de ataque | `1` |

</details>

<details>
<summary><b>Lista de baneados e IPs ignoradas</b> (4 variables)</summary>

Compartir listas de baneados con otras instancias y tráfico que nunca debe rastrearse.

| Variable de entorno | Descripción | Predeterminado |
|----------------------|-------------|---------|
| `KRAWL_IGNORED_IPS` | IPs/CIDR separados por comas que nunca se rastrean, banean ni exportan | Loopback, RFC1918, link-local, CGNAT |
| `KRAWL_BANLIST_EXPORT_PATH` | Ruta pública de descarga de la lista de baneados, p. ej. `/public_banlist.txt` (vacío = deshabilitado) | `""` |
| `KRAWL_BANLIST_SOURCES` | URL de listas de baneados externas separadas por comas para obtener y fusionar | Lista de baneados de la comunidad Krawl |
| `KRAWL_BANLIST_REFRESH_INTERVAL` | Segundos entre descargas de listas de baneados externas | `3600` |

</details>

<details>
<summary><b>Páginas de engaño generadas por IA</b> (10 variables)</summary>

Consulta la [documentación de generación con IA](https://github.com/blessedrebus/krawl/blob/HEAD/docs/ai_generation.md).

| Variable de entorno | Descripción | Predeterminado |
|----------------------|-------------|---------|
| `KRAWL_AI_ENABLED` | Habilitar páginas de engaño generadas por IA | `false` |
| `KRAWL_AI_PROVIDER` | Proveedor de IA (`"openrouter"` o `"openai"`) | `"openrouter"` |
| `KRAWL_AI_OPENAI_BASE_URL` | URL base opcional de OpenAI para endpoints de API personalizados | `"https://api.openai.com/v1"` |
| `KRAWL_AI_API_KEY` | Clave de API para el proveedor de IA | `Ninguna` |
| `KRAWL_AI_MODEL` | Modelo de IA a utilizar para la generación de páginas | `"nvidia/nemotron-3-super-120b-a12b:free"` |
| `KRAWL_AI_TIMEOUT` | Tiempo de espera de solicitud en segundos para llamadas a la API de IA | `60` |
| `KRAWL_AI_MAX_DAILY_REQUESTS` | Número máximo de páginas generadas por IA al día (0 = sin límite) | `0` |
| `KRAWL_AI_PROMPT` | Plantilla de prompt personalizada para la generación de páginas con IA | Prompt predeterminado |
| `KRAWL_AI_REASONING_ENABLED` | Habilitar tokens de razonamiento (solo modelos de razonamiento de OpenRouter) | `false` |
| `KRAWL_AI_REASONING_EFFORT` | Esfuerzo de razonamiento (`none`, `minimal`, `low`, `medium`, `high`, `xhigh`) | `"medium"` |

</details>

<details>
<summary><b>Modo escalable: PostgreSQL y Redis</b> (13 variables)</summary>

Solo se utiliza cuando `KRAWL_MODE=scalable`. Consulta [Modos de despliegue](https://github.com/blessedrebus/krawl/blob/HEAD/docs/deployment-modes.md).

| Variable de entorno | Descripción | Predeterminado |
|----------------------|-------------|---------|
| `KRAWL_MODE` | Modo de despliegue (`standalone` o `scalable`) | `standalone` |
| `KRAWL_POSTGRES_HOST` | Nombre de host de PostgreSQL | `localhost` |
| `KRAWL_POSTGRES_PORT` | Puerto de PostgreSQL | `5432` |
| `KRAWL_POSTGRES_USER` | Usuario de PostgreSQL | `krawl` |
| `KRAWL_POSTGRES_PASSWORD` | Contraseña de PostgreSQL | `krawl` |
| `KRAWL_POSTGRES_DATABASE` | Nombre de la base de datos de PostgreSQL | `krawl` |
| `KRAWL_REDIS_HOST` | Nombre de host de Redis | `localhost` |
| `KRAWL_REDIS_PORT` | Puerto de Redis | `6379` |
| `KRAWL_REDIS_DB` | Número de base de datos de Redis | `0` |
| `KRAWL_REDIS_PASSWORD` | Contraseña de Redis | Ninguna |
| `KRAWL_REDIS_CACHE_TTL` | TTL en segundos para los datos de precalentamiento del panel | `600` |
| `KRAWL_REDIS_HOT_TTL` | TTL en segundos para datos de ruta activa (información de baneos, categorías de IP) | `30` |
| `KRAWL_REDIS_TABLE_TTL` | TTL en segundos para las tablas paginadas del panel | `120` |

</details>


Por ejemplo```bash
# Set canary token
export CONFIG_LOCATION="config.yaml"
export KRAWL_CANARY_TOKEN_URL="http://your-canary-token-url"

# Set number of pages range (min,max format)
export KRAWL_LINKS_PER_PAGE_RANGE="5,25"

# Set analyzer thresholds
export KRAWL_HTTP_RISKY_METHODS_THRESHOLD="0.2"
export KRAWL_VIOLATED_ROBOTS_THRESHOLD="0.15"

# Set custom dashboard path and password
export KRAWL_DASHBOARD_SECRET_PATH="/my-secret-dashboard"
export KRAWL_DASHBOARD_PASSWORD="my-secret-password"

Ejemplo de una ejecución de Docker con variables de entorno (modo independiente):```bash docker run -d
-p 5000:5000
-e KRAWL_MODE=standalone
-e KRAWL_PORT=5000
-e KRAWL_DELAY=100
-e KRAWL_DASHBOARD_PASSWORD="my-secret-password"
-e KRAWL_CUSTOM_TEMPLATE_PATH="/templates/custom_page.html"
-e KRAWL_CANARY_TOKEN_URL="http://your-canary-token-url"
--name krawl
ghcr.io/blessedrebus/krawl:latest

## Usar Krawl para bloquear IPs maliciosas
Krawl utiliza un sistema basado en reputación para clasificar las direcciones IP de atacantes y ofrece dos formas de exportar listas de IP para la integración con firewalls.

El endpoint `/api/export-ips` consulta la base de datos directamente y admite el filtrado por categoría de IP (`attacker`, `bad_crawler`, `regular_user`, `good_crawler`) y formato de salida (`raw`, `iptables`, `nftables`):```bash
curl "https://your-krawl-instance/<DASHBOARD-PATH>/api/export-ips?categories=attacker&fwtype=raw"

Esto permite el bloqueo automático de tráfico malicioso en varias plataformas:

Para ver todos los parámetros de la API, ejemplos y cómo agregar formatos de firewall personalizados, consulta la documentación de Firewall Exporters.

Krawl también puede enviar IPs bloqueadas directamente a una lista de IPs de cuenta de Cloudflare para usarlas en reglas WAF. La sincronización se ejecuta como una tarea en segundo plano y actualiza la lista mediante un reemplazo completo en un intervalo configurable. Consulta la documentación de Cloudflare Banlist Sync.

Reputación de IP

Krawl utiliza tareas que analizan el tráfico reciente para construir y actualizar continuamente una puntuación de reputación de IP. Se ejecuta periódicamente y evalúa cada dirección IP activa basándose en múltiples indicadores de comportamiento para clasificarla como atacante, rastreador o usuario regular. Los umbrales son totalmente personalizables.

reputación de IP

El análisis incluye:

  • Uso de métodos HTTP riesgosos (p. ej., proporciones de POST, PUT, DELETE)
  • Violaciones de robots.txt
  • Anomalías en la temporización de solicitudes (patrones de ráfaga o irregulares)
  • Consistencia de User-Agent
  • Detección de URL de ataque (p. ej., patrones de inyección SQL, XSS)

Cada señal contribuye a un modelo de puntuación ponderado que asigna una categoría de reputación:

  • attacker
  • bad_crawler
  • good_crawler
  • regular_user
  • unknown (para datos insuficientes)

Las puntuaciones y métricas resultantes se almacenan en la base de datos y Krawl las utiliza para alimentar paneles de control, seguimiento de reputación y acciones de mitigación automatizadas, como el bloqueo de IP o la integración con firewall.

Páginas de engaño generadas por IA

Krawl puede generar automáticamente páginas de engaño realistas utilizando modelos de IA de las APIs de OpenRouter o OpenAI. Esta función crea páginas honeypot únicas y plausibles sobre la marcha para engañar a los atacantes sin necesidad de crear páginas manualmente.

Características principales:

  • Generación dinámica: Crea páginas HTML únicas para cualquier ruta de solicitud
  • Caché inteligente: Almacena en caché las páginas generadas para evitar llamadas API redundantes
  • Límite de tasa diario: Controla los costos de API con límites de solicitudes configurables
  • Múltiples proveedores: Compatibilidad con OpenRouter (opciones gratuitas) y OpenAI
  • Respaldo elegante: Vuelve al honeypot estándar cuando está deshabilitado o se alcanza el límite
  • Servicio desde caché: Las páginas generadas previamente se sirven incluso cuando la IA está deshabilitada

Configuración rápida:```yaml ai: enabled: true provider: "openrouter" openai_base_url: "your-custom-base-url" api_key: "your-api-key" model: "nvidia/nemotron-3-super-120b-a12b:free" timeout: 60 max_daily_requests: 10

Para conocer la configuración detallada y el uso, consulta la [documentación de generación con IA](https://github.com/blessedrebus/krawl/blob/HEAD/docs/ai_generation.md).

También puedes **contribuir con plantillas de engaño** abriendo un PR; consulta [Contribución de plantillas de engaño](https://github.com/blessedrebus/krawl/blob/HEAD/docs/deception_pages.md#contributing-deception-templates-via-pr).

## Ejecución tras un proxy inverso o CDN

**NGINX, Traefik y otros proxies como CloudFlare** necesitan reenvío de cabeceras para que Krawl pueda ver la IP real. Consulta la [documentación de proxy inverso](https://github.com/blessedrebus/krawl/blob/HEAD/docs/reverse-proxy.md) para ver ejemplos de configuración y la lista completa de cabeceras.

## Métricas y monitorización

Krawl expone métricas de [Prometheus](https://prometheus.io/) en `/<dashboard_secret_path>/metrics` (habilitado por defecto) e incluye un panel de [Grafana](https://grafana.com/) listo para importar en [`grafana-dashboard.json`](https://github.com/blessedrebus/krawl/blob/HEAD/grafana-dashboard.json).

Consulta la [documentación de monitorización](https://github.com/blessedrebus/krawl/blob/HEAD/docs/monitoring.md) para ver la lista completa de métricas, los pasos de importación de Grafana y la configuración de scraping de Prometheus / Kubernetes (`ServiceMonitor`).

## Documentación adicional

| Tema | Descripción |
|-------|-------------|
| [AI Generation](https://github.com/blessedrebus/krawl/blob/HEAD/docs/ai_generation.md) | Configura páginas de engaño generadas por IA usando OpenRouter u OpenAI |
| [Deception Pages](https://github.com/blessedrebus/krawl/blob/HEAD/docs/deception_pages.md) | Gestiona, importa y exporta páginas de engaño; operaciones masivas y filtrado por fecha |
| [Deployment Modes](https://github.com/blessedrebus/krawl/blob/HEAD/docs/deployment-modes.md) | Modo independiente (SQLite) frente a escalable (PostgreSQL + Redis), configuración y migración de datos |
| [Honeypot](https://github.com/blessedrebus/krawl/blob/HEAD/docs/honeypot.md) | Visión general completa de las páginas honeypot: inicios de sesión falsos, listados de directorio, archivos de credenciales, trampas de SQLi/XSS/XXE/inyección de comandos y más |
| [Dashboard](https://github.com/blessedrebus/krawl/blob/HEAD/docs/dashboard.md) | Accede y explora el panel de monitorización en tiempo real |
| [Dashboard API](https://github.com/blessedrebus/krawl/blob/HEAD/docs/dashboard-api.md) | La propia API JSON de Krawl: referencia de endpoints, autenticación, documentación interactiva de OpenAPI y descargas de adjuntos |
| [External APIs](https://github.com/blessedrebus/krawl/blob/HEAD/docs/api.md) | APIs de terceros a las que Krawl consulta para obtener datos de IP, reputación y geolocalización |
| [Reverse Proxy](https://github.com/blessedrebus/krawl/blob/HEAD/docs/reverse-proxy.md) | Cómo desplegar Krawl detrás de NGINX o usar subdominios señuelo |
| [Database Backups](https://github.com/blessedrebus/krawl/blob/HEAD/docs/backups.md) | Habilita y configura el trabajo automático de volcado de la base de datos |
| [Canary Token](https://github.com/blessedrebus/krawl/blob/HEAD/docs/canary-token.md) | Configura activadores de alerta externos mediante canarytokens.org |
| [Wordlist](https://github.com/blessedrebus/krawl/blob/HEAD/docs/wordlist.md) | Personaliza nombres de usuario, contraseñas y listados de directorio falsos |
| [Architecture](https://github.com/blessedrebus/krawl/blob/HEAD/docs/architecture.md) | Visión técnica del código, el pipeline de peticiones, el esquema de la base de datos y las tareas en segundo plano |
| [Cloudflare Banlist Sync](https://github.com/blessedrebus/krawl/blob/HEAD/docs/cloudflare_banlist.md) | Envía las IP bloqueadas de Krawl a una lista de IP de cuenta de Cloudflare para usarlas en reglas WAF. La sincronización se ejecuta como tarea en segundo plano y actualiza la lista mediante reemplazo completo. |
| [Firewall Exporters](https://github.com/blessedrebus/krawl/blob/HEAD/docs/firewall-exporters.md) | Exporta listas de bloqueo de IP en formato bruto, iptables o nftables mediante API REST |
| [Tarpit](https://github.com/blessedrebus/krawl/blob/HEAD/docs/tarpit.md) | Ralentiza y envenena a los rastreadores de IA con respuestas retardadas y relleno de ruido |
| [Metrics & Monitoring](https://github.com/blessedrebus/krawl/blob/HEAD/docs/monitoring.md) | Endpoint de métricas de Prometheus, referencia de métricas expuestas, panel de Grafana y scraping con ServiceMonitor |

## Contribuir

¡Las contribuciones son bienvenidas! Por favor:
1. Haz un fork del repositorio
2. Crea una rama de características
3. Realiza tus cambios
4. Envía un pull request (¡explica los cambios!)


## Aviso legal
> [!CAUTION]
> Este es un sistema de engaño/honeypot. Despliégalo en entornos aislados y supervisa atentamente los eventos de seguridad. Úsalo de forma responsable y cumpliendo las leyes y normativas aplicables.

## Historial de estrellas
<img src="https://star-history.dera.page/svg?repos=BlessedRebuS/Krawl&amp;type=Date" width="600" alt="Gráfico de historial de estrellas" />
Leer más

Categorías

Seguridad de ContenedoresRecopilación de InformaciónSeguridad WebSeguridad de RedesSeguridad en la NubeInteligencia de AmenazasRespuesta a IncidentesAnti-BotSeguridad de IA