blessedrebus/krawlKrawl 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.
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.
Consejo: rastrea las rutas de robots.txt para diversión adicional
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.
Al desperdiciar los recursos de los atacantes, Krawl ayuda a distinguir claramente el comportamiento malicioso de los rastreadores legítimos.
Sus características incluyen:
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.
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:
Además, tras autenticarse con la contraseña del panel, dos pestañas protegidas quedan disponibles:
Para más detalles, consulta la documentación del panel.
Krawl admite dos modos de despliegue, controlados por el ajuste mode en config.yaml o por la variable de entorno KRAWL_MODE.
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á.
Escalable: diseñado para entornos de producción o honeypots de alto tráfico. El chart de Helm usa este modo por defecto.
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.
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.
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:
export_path: "/public_banlist.txt"
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
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:
values-minimal.yaml ---> Scalable (predeterminado)values-standalone.yaml ---> StandaloneConsulte Modos de implementación y Documentación del chart para obtener la configuración completa y las instrucciones de migración.
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.
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.
El análisis incluye:
Cada señal contribuye a un modelo de puntuación ponderado que asigna una categoría de reputación:
attackerbad_crawlergood_crawlerregular_userunknown (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.
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:
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&type=Date" width="600" alt="Gráfico de historial de estrellas" />
| Standalone | Escalable |
|---|
| Base de datos | SQLite (modo WAL) | PostgreSQL |
| Caché | Dict de Python en memoria | Redis (TTL multinivel) |
| Réplicas | 1 (instancia única) | 1+ (escalado horizontal) |
| Dependencias externas | Ninguna | PostgreSQL + Redis |
| Ideal para | Dev, homelabs, <500k peticiones | Producción, HA, >500k peticiones |