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 canarios.
Consejo: explora 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 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.
Incluye:
Puedes exponer fácilmente Krawl junto a tus otros servicios para protegerlos de rastreadores web y usuarios maliciosos mediante un proxy inverso. Para más detalles, consulta la documentación de Proxy Inverso.
Krawl proporciona un panel integral, 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 la configuración mode en config.yaml o la variable de entorno KRAWL_MODE.
Standalone: ideal para entornos de desarrollo u homelabs con bajos volúmenes de solicitudes. No requiere configuración adicional, solo ejecuta Krawl y funciona.
Escalable: diseñado para entornos de producción u honeypots de alto tráfico. El Helm chart usa este modo por defecto.
Para 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 regularmente con direcciones IP de atacantes que activaron sus trampas honeypot. La lista de bloqueo se publica semanalmente y está disponible para descarga, ayudando a la comunidad a bloquear preventivamente 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 extraer listas de otras instancias (o cualquier lista de IP en texto plano). Las IPs obtenidas se fusionan en 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
## Quickstart
### Ejecución con Docker
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 despliegue.
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 siguiente utiliza **contraseñas por defecto** (`krawl`/`krawl`). **Cámbielas antes de implementar 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 implementar, 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/main/docker). Para **desarrollo** (compilaciones desde el código fuente con recarga en caliente), use los archivos compose en [`docker/dev/`](https://github.com/blessedrebus/krawl/blob/main/docker/dev).
Para más detalles sobre ambos modos, consulte [Modos de despliegue](https://github.com/blessedrebus/krawl/blob/main/docs/deployment-modes.md).
### Kubernetes
**Krawl también está disponible de forma nativa en Kubernetes**. La instalación se puede realizar [mediante manifiesto](https://github.com/blessedrebus/krawl/blob/main/kubernetes/README.md) o [usando el chart de Helm](https://github.com/blessedrebus/krawl/blob/main/helm/README.md).
El chart de Helm **está predeterminado al modo escalable** con PostgreSQL y Redis incluidos:```bash
helm install krawl oci://ghcr.io/blessedrebus/krawl-chart --version 2.3.1 \
-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 mínimos de ejemplo para ambos modos:
values-minimal.yaml ---> Escalable (predeterminado)values-standalone.yaml ---> IndependienteConsulta Modos de implementación y Documentación del chart para obtener la configuración completa y las instrucciones de migración.
Ejecuta Krawl directamente con Python 3.13+ y uvicorn para desarrollo local o pruebas:```bash pip install -r requirements.txt uvicorn app:app --host 0.0.0.0 --port 5000 --app-dir src --no-server-header
Acceda 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
Puede utilizar el archivo [config.yaml](https://github.com/blessedrebus/krawl/blob/main/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 | Valor predeterminado |
|----------------------|-------------|---------|
| `CONFIG_LOCATION` | Ruta al archivo de configuración yaml | `config.yaml` |
| `KRAWL_PORT` | Puerto de escucha del servidor | `5000` |
| `KRAWL_DELAY` | Retardo de respuesta en milisegundos | `100` |
| `KRAWL_SERVER_HEADER` | Cabecera HTTP del servidor 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 respuesta de error (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 bloqueo en segundos para IPs con límite de velocidad superado | `600` |
</details>
<details>
<summary><b>Panel de control, métricas y registro</b> (8 variables)</summary>
Acceso al panel de control, precarga de caché, Prometheus y nivel de registro.
| Variable de entorno | Descripción | Valor predeterminado |
|----------------------|-------------|---------|
| `KRAWL_DASHBOARD_SECRET_PATH` | Ruta personalizada del panel de control | Generada automáticamente |
| `KRAWL_DASHBOARD_PASSWORD` | Contraseña para los paneles protegidos del panel de control | Generada automáticamente |
| `KRAWL_DASHBOARD_CACHE_WARMUP` | Precalcular los datos del panel de control cada 5 minutos para cargas de página instantáneas | `true` |
| `KRAWL_DASHBOARD_WARMUP_PAGES` | Número de páginas a precalentar por panel de tabla | `10` |
| `KRAWL_DASHBOARD_WARMUP_AGGREGATION` | Precalcular 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 (establecer en 1 para desactivar) | `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 de almacenamiento, tiempo de retención de datos y tarea de volcado.
| Variable de entorno | Descripción | Valor predeterminado |
|----------------------|-------------|---------|
| `KRAWL_DATABASE_PATH` | Ubicación del archivo de base de datos | `data/krawl.db` |
| `KRAWL_DATABASE_PERSIST_SUSPICIOUS_ONLY` | Persistir solo 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 páginas servidas a los atacantes.
| Variable de entorno | Descripción | Valor predeterminado |
|----------------------|-------------|---------|
| `KRAWL_TARPIT_ENABLED` | Atrapar agentes de IA con respuestas lentas y texto aleatorio | `false` |
| `KRAWL_TARPIT_DELAY_SECONDS` | Retardo 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 inicio | `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 | None |
| `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 | Valor predeterminado |
|----------------------|-------------|---------|
| `KRAWL_HTTP_RISKY_METHODS_THRESHOLD` | Umbral para la detección de métodos HTTP arriesgados | `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 | `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 agentes de usuario | `2` |
| `KRAWL_ATTACK_URLS_THRESHOLD` | Umbral para la detección de URL de ataque | `1` |
</details>
<details>
<summary><b>Lista de bloqueo e IPs ignoradas</b> (4 variables)</summary>
Compartir listas de bloqueo con otras instancias y tráfico que nunca se rastrea.
| Variable de entorno | Descripción | Valor predeterminado |
|----------------------|-------------|---------|
| `KRAWL_IGNORED_IPS` | IPs/CIDRs separados por comas que nunca se rastrean, bloquean o exportan | Loopback, RFC1918, link-local, CGNAT |
| `KRAWL_BANLIST_EXPORT_PATH` | Ruta pública de descarga de la lista de bloqueo, p. ej. `/public_banlist.txt` (vacío = desactivado) | `""` |
| `KRAWL_BANLIST_SOURCES` | URLs de listas de bloqueo ascendentes separadas por comas para obtener y fusionar | Lista de bloqueo comunitaria de Krawl |
| `KRAWL_BANLIST_REFRESH_INTERVAL` | Segundos entre obtenciones de listas de bloqueo ascendentes | `3600` |
</details>
<details>
<summary><b>Páginas de engaño generadas por IA</b> (10 variables)</summary>
Consulte la [documentación de generación con IA](https://github.com/blessedrebus/krawl/blob/main/docs/ai_generation.md).
| Variable de entorno | Descripción | Valor 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 de OpenAI opcional para endpoints de API personalizados | `"https://api.openai.com/v1"` |
| `KRAWL_AI_API_KEY` | Clave de API para el proveedor de IA | `None` |
| `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 = ilimitado) | `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`. Consulte [Modos de despliegue](https://github.com/blessedrebus/krawl/blob/main/docs/deployment-modes.md).
| Variable de entorno | Descripción | Valor 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 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 | None |
| `KRAWL_REDIS_CACHE_TTL` | TTL en segundos para los datos de precarga del panel de control | `600` |
| `KRAWL_REDIS_HOT_TTL` | TTL en segundos para datos de ruta activa (información de bloqueo, categorías de IP) | `30` |
| `KRAWL_REDIS_TABLE_TTL` | TTL en segundos para tablas paginadas del panel de control | `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 los atacantes y ofrece dos formas de exportar listas de IP para la integración con cortafuegos.
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 conocer todos los parámetros de la API, ejemplos y cómo añadir formatos de firewall personalizados, consulta la documentación de Firewall Exporters.
Krawl también puede enviar IPs bloqueadas directamente a una Cloudflare Account IP List para usarlas en reglas WAF. La sincronización se ejecuta como una tarea en segundo plano y actualiza la lista mediante 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 habitual. Los umbrales son totalmente personalizables.
El análisis incluye:
Cada señal contribuye a un modelo de puntuación ponderada 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 impulsar 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 u 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 la configuración detallada y el uso, consulta la [documentación de Generación con IA](https://github.com/blessedrebus/krawl/blob/main/docs/ai_generation.md).
También puedes **contribuir con plantillas de engaño** abriendo un PR; consulta [Contribuir con Plantillas de Engaño](https://github.com/blessedrebus/krawl/blob/main/docs/deception_pages.md#contributing-deception-templates-via-pr).
## Ejecución Detrás de 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/main/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/main/grafana-dashboard.json).
Consulta la [documentación de Monitorización](https://github.com/blessedrebus/krawl/blob/main/docs/monitoring.md) para ver la lista completa de métricas, los pasos de importación en Grafana y la configuración de recopilación con Prometheus / Kubernetes (`ServiceMonitor`).
## Documentación Adicional
| Tema | Descripción |
|-------|-------------|
| [Generación con IA](https://github.com/blessedrebus/krawl/blob/main/docs/ai_generation.md) | Configura páginas de engaño generadas por IA usando OpenRouter u OpenAI |
| [Páginas de Engaño](https://github.com/blessedrebus/krawl/blob/main/docs/deception_pages.md) | Gestiona, importa y exporta páginas de engaño; operaciones masivas y filtrado por fecha |
| [Modos de Despliegue](https://github.com/blessedrebus/krawl/blob/main/docs/deployment-modes.md) | Modo independiente (SQLite) vs. escalable (PostgreSQL + Redis), configuración y migración de datos |
| [Honeypot](https://github.com/blessedrebus/krawl/blob/main/docs/honeypot.md) | Visión general completa de las páginas honeypot: inicios de sesión falsos, listados de directorios, archivos de credenciales, trampas de SQLi/XSS/XXE/inyección de comandos y más |
| [Panel de Control](https://github.com/blessedrebus/krawl/blob/main/docs/dashboard.md) | Accede y explora el panel de monitorización en tiempo real |
| [API del Panel de Control](https://github.com/blessedrebus/krawl/blob/main/docs/dashboard-api.md) | La propia API JSON de Krawl: referencia de endpoints, autenticación, documentación interactiva de OpenAPI y descargas de adjuntos |
| [APIs Externas](https://github.com/blessedrebus/krawl/blob/main/docs/api.md) | APIs de terceros a las que Krawl llama para obtener datos de IP, reputación y geolocalización |
| [Proxy Inverso](https://github.com/blessedrebus/krawl/blob/main/docs/reverse-proxy.md) | Cómo desplegar Krawl detrás de NGINX o usar subdominios señuelo |
| [Copias de Seguridad de la Base de Datos](https://github.com/blessedrebus/krawl/blob/main/docs/backups.md) | Habilita y configura el trabajo automático de volcado de la base de datos |
| [Token Canario](https://github.com/blessedrebus/krawl/blob/main/docs/canary-token.md) | Configura alertas externas mediante canarytokens.org |
| [Lista de Palabras](https://github.com/blessedrebus/krawl/blob/main/docs/wordlist.md) | Personaliza nombres de usuario, contraseñas y listados de directorios falsos |
| [Arquitectura](https://github.com/blessedrebus/krawl/blob/main/docs/architecture.md) | Visión técnica del código, el pipeline de solicitudes, el esquema de la base de datos y las tareas en segundo plano |
| [Sincronización de Lista de Bloqueo de Cloudflare](https://github.com/blessedrebus/krawl/blob/main/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. |
| [Exportadores de Firewall](https://github.com/blessedrebus/krawl/blob/main/docs/firewall-exporters.md) | Exporta listas de bloqueo de IP en formato raw, iptables o nftables mediante API REST |
| [Tarpit](https://github.com/blessedrebus/krawl/blob/main/docs/tarpit.md) | Ralentiza y envenena a los rastreadores de IA con respuestas retardadas y relleno de ruido |
| [Métricas y Monitorización](https://github.com/blessedrebus/krawl/blob/main/docs/monitoring.md) | Endpoint de métricas de Prometheus, referencia de métricas expuestas, panel de Grafana y recopilación con ServiceMonitor |
## Contribuciones
¡Las contribuciones son bienvenidas! Por favor:
1. Haz un fork del repositorio
2. Crea una rama de funcionalidad
3. Realiza tus cambios
4. Envía una solicitud de extracción (¡explica los cambios!)
## Aviso Legal
> [!CAUTION]
> Este es un sistema de engaño/honeypot. Despliégalo en entornos aislados y supervisa cuidadosamente los eventos de seguridad. Úsalo de forma responsable y en cumplimiento de las leyes y regulaciones aplicables.
## Historial de Estrellas
<img src="https://star-history.dera.page/svg?repos=BlessedRebuS/Krawl&type=Date" width="600" alt="Gráfico del Historial de Estrellas" />
| Standalone | Escalable |
|---|
| Base de datos | SQLite (modo WAL) | PostgreSQL |
| Caché | Dict de Python en memoria | Redis (TTL de múltiples niveles) |
| Réplicas | 1 (instancia única) | 1+ (escalado horizontal) |
| Dependencias externas | Ninguna | PostgreSQL + Redis |
| Ideal para | Desarrollo, homelabs, <500k solicitudes | Producción, alta disponibilidad, >500k solicitudes |