blessedrebus/krawlKrawl ist ein anpassbarer, leichter, cloud-nativer Web-Täuschungsserver und Anti-Crawler, der gefälschte Webanwendungen mit offensichtlichen Schwachstellen erstellt, indem realistische, zufällig generierte Köderdaten und KI-generierte HTML-Vorlagen verwendet werden.
Ein moderner, anpassbarer Web-Honeypot-Server, der entwickelt wurde, um bösartige Aktivitäten von Angreifern und Web-Crawlern durch trügerische Webseiten, gefälschte Anmeldedaten und Canary-Tokens zu erkennen und zu verfolgen.
Tipp: Durchsuche die robots.txt-Pfade für zusätzlichen Spaß
Krawl ist ein cloud-nativer Täuschungsserver, der entwickelt wurde, um bösartige Angreifer, Web-Crawler und automatisierte Scanner zu erkennen, zu verzögern und zu analysieren.
Er erstellt realistische gefälschte Webanwendungen voller verlockender Ziele wie Admin-Panels, Konfigurationsdateien und offengelegter gefälschter Anmeldedaten, um verdächtige Aktivitäten anzuziehen und zu identifizieren.
Indem Krawl die Ressourcen von Angreifern verschwendet, hilft es, bösartiges Verhalten klar von legitimen Crawlern zu unterscheiden.
Es bietet:
Du kannst Krawl problemlos neben deinen anderen Diensten über einen Reverse-Proxy bereitstellen, um sie vor Web-Crawlern und bösartigen Benutzern zu schützen. Weitere Details findest du in der Reverse-Proxy-Dokumentation.
Krawl bietet ein umfassendes Dashboard, das über einen zufälligen geheimen Pfad, der beim Start generiert wird, oder über einen benutzerdefinierten Pfad, der über KRAWL_DASHBOARD_SECRET_PATH konfiguriert wird, erreichbar ist. Dadurch bleibt das Dashboard vor Angreifern verborgen, die deinen Honeypot scannen.
Das Dashboard ist in sechs Tabs organisiert:
Zusätzlich werden nach der Authentifizierung mit dem Dashboard-Passwort zwei geschützte Tabs verfügbar:
Weitere Details findest du in der Dashboard-Dokumentation.
Krawl unterstützt zwei Bereitstellungsmodi, die über die Einstellung mode in config.yaml oder die Umgebungsvariable KRAWL_MODE gesteuert werden.
Standalone: Ideal für Entwicklungsumgebungen oder Homelabs mit geringen Anfragezahlen. Keine zusätzliche Konfiguration erforderlich – einfach Krawl ausführen und es funktioniert.
Skalierbar: Entwickelt für Produktionsumgebungen oder Honeypots mit hohem Datenverkehr. Das Helm-Chart verwendet standardmäßig diesen Modus.
Für detaillierte Konfiguration, Docker-Compose-Beispiele, Kubernetes/Helm-Setup und Schritt-für-Schritt-Migrationsanleitungen siehe die Dokumentation zu Bereitstellungsmodi.
Krawl pflegt eine regelmäßig aktualisierte banlist.txt mit IP-Adressen von Angreifern, die seine Honeypot-Fallen ausgelöst haben. Die Banlist wird wöchentlich veröffentlicht und steht zum Download bereit, was der Community hilft, bekannte bösartige Akteure präventiv zu blockieren – auch ohne Krawl zu verwenden.
Die Banlist kann auch direkt abgerufen werden unter: https://demo.krawlme.com/das_dashboard/api/export-ips?categories=attacker&fwtype=raw.
Krawl-Instanzen können ihre Banlisten föderieren: Jede kann ihre eigene Liste auf einem nicht authentifizierten Pfad veröffentlichen und Listen von anderen Instanzen (oder beliebigen Klartext-IP-Listen) abrufen. Abgerufene IPs werden in die lokalen Sperrentscheidungen übernommen und im Dashboard angezeigt.```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
### Docker-Ausführung
Führen Sie Krawl im eigenständigen Modus mit dem neuesten Image aus:```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
Access the server at http://localhost:5000
Erstelle eine docker-compose.yaml mit einem der beiden Bereitstellungsmodi.
Standalone: nur der Krawl-Server mit Sqlite-Speicher:```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:
**Skalierbar**: mit PostgreSQL und Redis:
> [!CAUTION]
> Das folgende Beispiel verwendet **Standard-Passwörter** (`krawl`/`krawl`). **Ändern Sie diese, bevor Sie in der Produktion bereitstellen.**```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:
Um bereitzustellen, führen Sie einfach aus```bash docker compose up -d
Produktionsreife Compose-Dateien sind ebenfalls im Verzeichnis [`docker/`](https://github.com/blessedrebus/krawl/blob/main/docker) verfügbar. Für die **Entwicklung** (Builds aus dem Quellcode mit Hot-Reload) verwenden Sie die Compose-Dateien in [`docker/dev/`](https://github.com/blessedrebus/krawl/blob/main/docker/dev).
Weitere Details zu beiden Modi finden Sie unter [Bereitstellungsmodi](https://github.com/blessedrebus/krawl/blob/main/docs/deployment-modes.md).
### Kubernetes
**Krawl ist auch nativ auf Kubernetes verfügbar**. Die Installation kann entweder [über Manifest](https://github.com/blessedrebus/krawl/blob/main/kubernetes/README.md) oder [mithilfe des Helm-Charts](https://github.com/blessedrebus/krawl/blob/main/helm/README.md) erfolgen.
Das Helm-Chart **standardmäßig im skalierbaren Modus** mit gebündeltem PostgreSQL und Redis:```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
Minimale Beispielwerte-Dateien sind für beide Modi bereitgestellt:
values-minimal.yaml ---> Skalierbar (Standard)values-standalone.yaml ---> EigenständigSiehe Bereitstellungsmodi und Chart-Dokumentation für die vollständige Konfiguration und Migrationsanweisungen.
Führen Sie Krawl direkt mit Python 3.13+ und uvicorn für die lokale Entwicklung oder zum Testen aus:```bash pip install -r requirements.txt uvicorn app:app --host 0.0.0.0 --port 5000 --app-dir src --no-server-header
Greife auf den Server unter `http://localhost:5000` zu
## Konfiguration
Krawl verwendet eine **Konfigurationshierarchie**, bei der **Umgebungsvariablen Vorrang vor der Konfigurationsdatei haben**. Dieser Ansatz wird für Docker-Bereitstellungen und eine schnelle Anpassung direkt nach der Installation empfohlen.
### Konfiguration über config.yaml
Du kannst die Datei [config.yaml](https://github.com/blessedrebus/krawl/blob/main/config.yaml) für erweiterte Konfigurationen verwenden, z. B. für Docker-Compose- oder Helm-Chart-Bereitstellungen.
### Konfiguration über Umgebungsvariablen
Alle Einstellungen können als Umgebungsvariablen bereitgestellt werden, die `config.yaml` überschreiben.
Der Variablenname ist `KRAWL_` plus der Einstellungspfad in Großbuchstaben, also wird `dashboard.password`
zu `KRAWL_DASHBOARD_PASSWORD`.
<details>
<summary><b>Server und Linkgenerierung</b> (12 Variablen)</summary>
Wie Krawl sich präsentiert und das Labyrinth der generierten Seiten gestaltet.
| Umgebungsvariable | Beschreibung | Standard |
|----------------------|-------------|---------|
| `CONFIG_LOCATION` | Pfad zur YAML-Konfigurationsdatei | `config.yaml` |
| `KRAWL_PORT` | Listening-Port des Servers | `5000` |
| `KRAWL_DELAY` | Antwortverzögerung in Millisekunden | `100` |
| `KRAWL_SERVER_HEADER` | HTTP-Server-Header für die Täuschung | `""` |
| `KRAWL_LINKS_LENGTH_RANGE` | Linklängenbereich als `min,max` | `5,15` |
| `KRAWL_LINKS_PER_PAGE_RANGE` | Links pro Seite als `min,max` | `10,15` |
| `KRAWL_CHAR_SPACE` | Zeichen, die für die Linkgenerierung verwendet werden | `abcdefgh...` |
| `KRAWL_MAX_COUNTER` | Anfangswert des Zählers | `10` |
| `KRAWL_PROBABILITY_ERROR_CODES` | Wahrscheinlichkeit von Fehlerantworten (0-100 %) | `0` |
| `KRAWL_INFINITE_PAGES_FOR_MALICIOUS` | Unendliche Seiten für bösartige IPs bereitstellen | `true` |
| `KRAWL_MAX_PAGES_LIMIT` | Maximale Seitenbegrenzung für Crawler | `250` |
| `KRAWL_BAN_DURATION_SECONDS` | Sperrdauer in Sekunden für IPs mit Ratenbegrenzung | `600` |
</details>
<details>
<summary><b>Dashboard, Metriken und Protokollierung</b> (8 Variablen)</summary>
Dashboard-Zugriff, Cache-Vorwärmung, Prometheus und Protokollstufe.
| Umgebungsvariable | Beschreibung | Standard |
|----------------------|-------------|---------|
| `KRAWL_DASHBOARD_SECRET_PATH` | Benutzerdefinierter Dashboard-Pfad | Automatisch generiert |
| `KRAWL_DASHBOARD_PASSWORD` | Passwort für geschützte Dashboard-Panels | Automatisch generiert |
| `KRAWL_DASHBOARD_CACHE_WARMUP` | Dashboard-Daten alle 5 Minuten vorberechnen für sofortige Seitenladezeiten | `true` |
| `KRAWL_DASHBOARD_WARMUP_PAGES` | Anzahl der Seiten, die pro Tabellen-Panel vorab aufgewärmt werden | `10` |
| `KRAWL_DASHBOARD_WARMUP_AGGREGATION` | Vollständige top_paths/top_ua-Aggregationen für Abfragen ohne Verzögerung vorberechnen | `false` |
| `KRAWL_DASHBOARD_TOP_N_MIN_COUNT` | Mindestanzahl an Zugriffen für Panels mit Top-Pfaden/Benutzeragenten (auf 1 setzen, um zu deaktivieren) | `5` |
| `KRAWL_METRICS_ENABLED` | Prometheus-Metriken unter `/<dashboard_path>/metrics` verfügbar machen | `true` |
| `KRAWL_LOG_LEVEL` | Protokollstufe der Anwendung (`DEBUG`, `INFO`, `WARNING`, `ERROR`) | `INFO` |
</details>
<details>
<summary><b>Datenbank, Aufbewahrung und Backups</b> (6 Variablen)</summary>
Speicherort, wie lange Daten aufbewahrt werden, und der Dump-Job.
| Umgebungsvariable | Beschreibung | Standard |
|----------------------|-------------|---------|
| `KRAWL_DATABASE_PATH` | Speicherort der Datenbankdatei | `data/krawl.db` |
| `KRAWL_DATABASE_PERSIST_SUSPICIOUS_ONLY` | Nur verdächtige Anfragen im Zugriffsprotokoll speichern | `false` |
| `KRAWL_DATABASE_RETENTION_DAYS` | Tage, die Daten in der Datenbank aufbewahrt werden | `30` |
| `KRAWL_BACKUPS_PATH` | Pfad, in dem Datenbank-Dumps gespeichert werden | `backups` |
| `KRAWL_BACKUPS_CRON` | Cron-Ausdruck zur Steuerung des Backup-Job-Zeitplans | `*/30 * * * *` |
| `KRAWL_BACKUPS_ENABLED` | Boolescher Wert zum Aktivieren des DB-Dump-Jobs | `true` |
</details>
<details>
<summary><b>Fallen: Tarpit, Täuschungsseiten und Canary</b> (6 Variablen)</summary>
Opt-in-Fallen und die Seiten, die Angreifern bereitgestellt werden.
| Umgebungsvariable | Beschreibung | Standard |
|----------------------|-------------|---------|
| `KRAWL_TARPIT_ENABLED` | KI-Agenten mit langsamen Antworten und zufälligem Text in die Falle locken | `false` |
| `KRAWL_TARPIT_DELAY_SECONDS` | Zusätzliche Verzögerung in Sekunden pro Antwort, wenn der Tarpit aktiv ist | `5` |
| `KRAWL_DECEPTION_IMPORT_PAGES` | Täuschungsseiten beim Start automatisch aus `src/templates/deception/` importieren | `true` |
| `KRAWL_CUSTOM_TEMPLATE_PATH` | Pfad innerhalb des Containers zu einer benutzerdefinierten HTML-Vorlage. Die Vorlage muss die Platzhalter `{counter}` und `{content}` enthalten. | `/templates/custom_page.html` |
| `KRAWL_CANARY_TOKEN_URL` | Externe Canary-Token-URL | Keine |
| `KRAWL_CANARY_TOKEN_TRIES` | Anfragen, bevor das Canary-Token angezeigt wird | `10` |
</details>
<details>
<summary><b>IP-Reputations-Analysator</b> (6 Variablen)</summary>
Schwellenwerte, die bestimmen, wie eine IP klassifiziert wird.
| Umgebungsvariable | Beschreibung | Standard |
|----------------------|-------------|---------|
| `KRAWL_HTTP_RISKY_METHODS_THRESHOLD` | Schwellenwert für die Erkennung riskanter HTTP-Methoden | `0.1` |
| `KRAWL_VIOLATED_ROBOTS_THRESHOLD` | Schwellenwert für robots.txt-Verstöße | `0.1` |
| `KRAWL_UNEVEN_REQUEST_TIMING_THRESHOLD` | Variationskoeffizient-Schwellenwert für das Timing | `0.5` |
| `KRAWL_UNEVEN_REQUEST_TIMING_TIME_WINDOW_SECONDS` | Zeitfenster für die Analyse des Anfrage-Timings in Sekunden | `300` |
| `KRAWL_USER_AGENTS_USED_THRESHOLD` | Schwellenwert für die Erkennung mehrerer Benutzeragenten | `2` |
| `KRAWL_ATTACK_URLS_THRESHOLD` | Schwellenwert für die Erkennung von Angriffs-URLs | `1` |
</details>
<details>
<summary><b>Sperrliste und ignorierte IPs</b> (4 Variablen)</summary>
Sperrlisten mit anderen Instanzen teilen und Datenverkehr, der nie verfolgt wird.
| Umgebungsvariable | Beschreibung | Standard |
|----------------------|-------------|---------|
| `KRAWL_IGNORED_IPS` | Kommagetrennte IPs/CIDRs, die nie verfolgt, gesperrt oder exportiert werden | Loopback, RFC1918, Link-Local, CGNAT |
| `KRAWL_BANLIST_EXPORT_PATH` | Öffentlicher Download-Pfad für die Sperrliste, z. B. `/public_banlist.txt` (leer = deaktiviert) | `""` |
| `KRAWL_BANLIST_SOURCES` | Kommagetrennte Upstream-Sperrlisten-URLs zum Abrufen und Zusammenführen | Krawl-Community-Sperrliste |
| `KRAWL_BANLIST_REFRESH_INTERVAL` | Sekunden zwischen Upstream-Sperrlisten-Abrufen | `3600` |
</details>
<details>
<summary><b>KI-generierte Täuschungsseiten</b> (10 Variablen)</summary>
Siehe die [KI-Generierungsdokumentation](https://github.com/blessedrebus/krawl/blob/main/docs/ai_generation.md).
| Umgebungsvariable | Beschreibung | Standard |
|----------------------|-------------|---------|
| `KRAWL_AI_ENABLED` | KI-generierte Täuschungsseiten aktivieren | `false` |
| `KRAWL_AI_PROVIDER` | KI-Anbieter (`"openrouter"` oder `"openai"`) | `"openrouter"` |
| `KRAWL_AI_OPENAI_BASE_URL` | Optionale OpenAI-Basis-URL für benutzerdefinierte API-Endpunkte | `"https://api.openai.com/v1"` |
| `KRAWL_AI_API_KEY` | API-Schlüssel für den KI-Anbieter | `None` |
| `KRAWL_AI_MODEL` | KI-Modell, das für die Seitengenerierung verwendet wird | `"nvidia/nemotron-3-super-120b-a12b:free"` |
| `KRAWL_AI_TIMEOUT` | Anforderungs-Timeout in Sekunden für KI-API-Aufrufe | `60` |
| `KRAWL_AI_MAX_DAILY_REQUESTS` | Maximale Anzahl KI-generierter Seiten pro Tag (0 = unbegrenzt) | `0` |
| `KRAWL_AI_PROMPT` | Benutzerdefinierte Prompt-Vorlage für die KI-Seitengenerierung | Standard-Prompt |
| `KRAWL_AI_REASONING_ENABLED` | Reasoning-Tokens aktivieren (nur OpenRouter-Reasoning-Modelle) | `false` |
| `KRAWL_AI_REASONING_EFFORT` | Reasoning-Aufwand (`none`, `minimal`, `low`, `medium`, `high`, `xhigh`) | `"medium"` |
</details>
<details>
<summary><b>Skalierbarer Modus: PostgreSQL und Redis</b> (13 Variablen)</summary>
Wird nur verwendet, wenn `KRAWL_MODE=scalable`. Siehe [Bereitstellungsmodi](https://github.com/blessedrebus/krawl/blob/main/docs/deployment-modes.md).
| Umgebungsvariable | Beschreibung | Standard |
|----------------------|-------------|---------|
| `KRAWL_MODE` | Bereitstellungsmodus (`standalone` oder `scalable`) | `standalone` |
| `KRAWL_POSTGRES_HOST` | PostgreSQL-Hostname | `localhost` |
| `KRAWL_POSTGRES_PORT` | PostgreSQL-Port | `5432` |
| `KRAWL_POSTGRES_USER` | PostgreSQL-Benutzername | `krawl` |
| `KRAWL_POSTGRES_PASSWORD` | PostgreSQL-Passwort | `krawl` |
| `KRAWL_POSTGRES_DATABASE` | PostgreSQL-Datenbankname | `krawl` |
| `KRAWL_REDIS_HOST` | Redis-Hostname | `localhost` |
| `KRAWL_REDIS_PORT` | Redis-Port | `6379` |
| `KRAWL_REDIS_DB` | Redis-Datenbanknummer | `0` |
| `KRAWL_REDIS_PASSWORD` | Redis-Passwort | None |
| `KRAWL_REDIS_CACHE_TTL` | TTL in Sekunden für Dashboard-Vorwärmdaten | `600` |
| `KRAWL_REDIS_HOT_TTL` | TTL in Sekunden für Hot-Path-Daten (Sperrinformationen, IP-Kategorien) | `30` |
| `KRAWL_REDIS_TABLE_TTL` | TTL in Sekunden für paginierte Dashboard-Tabellen | `120` |
</details>
Zum Beispiel```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"
Beispiel für einen Docker-Run mit Umgebungsvariablen (Standalone-Modus):```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
## Verwende Krawl, um bösartige IPs zu sperren
Krawl verwendet ein reputationsbasiertes System, um IP-Adressen von Angreifern zu klassifizieren, und bietet zwei Möglichkeiten, IP-Listen für die Firewall-Integration zu exportieren.
Der Endpunkt `/api/export-ips` fragt die Datenbank direkt ab und unterstützt die Filterung nach IP-Kategorie (`attacker`, `bad_crawler`, `regular_user`, `good_crawler`) sowie das Ausgabeformat (`raw`, `iptables`, `nftables`):```bash
curl "https://your-krawl-instance/<DASHBOARD-PATH>/api/export-ips?categories=attacker&fwtype=raw"
Dies ermöglicht die automatische Blockierung von bösartigem Datenverkehr auf verschiedenen Plattformen:
Für vollständige API-Parameter, Beispiele und das Hinzufügen benutzerdefinierter Firewall-Formate siehe die Firewall-Exporters-Dokumentation.
Krawl kann gesperrte IPs auch direkt an eine Cloudflare-Account-IP-Liste für die Verwendung in WAF-Regeln pushen. Die Synchronisierung läuft als Hintergrundaufgabe und aktualisiert die Liste durch vollständigen Ersatz in einem konfigurierbaren Intervall. Siehe die Cloudflare-Banlist-Sync-Dokumentation.
Krawl verwendet Aufgaben, die aktuellen Datenverkehr analysieren, um eine IP-Reputation aufzubauen und kontinuierlich zu aktualisieren. Sie läuft periodisch und bewertet jede aktive IP-Adresse anhand mehrerer Verhaltensindikatoren, um sie als Angreifer, Crawler oder regulären Benutzer zu klassifizieren. Schwellenwerte sind vollständig anpassbar.
Die Analyse umfasst:
Jedes Signal trägt zu einem gewichteten Bewertungsmodell bei, das eine Reputationskategorie zuweist:
attackerbad_crawlergood_crawlerregular_userunknown (bei unzureichenden Daten)Die resultierenden Bewertungen und Metriken werden in der Datenbank gespeichert und von Krawl verwendet, um Dashboards, Reputationsverfolgung und automatisierte Abwehrmaßnahmen wie IP-Sperrung oder Firewall-Integration zu steuern.
Krawl kann mithilfe von KI-Modellen aus OpenRouter- oder OpenAI-APIs automatisch realistische Täuschungsseiten generieren. Diese Funktion erstellt spontan einzigartige, plausible Honeypot-Seiten, um Angreifer ohne manuelle Seitenerstellung zu täuschen.
Hauptfunktionen:
Schnelle Einrichtung:```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
Für detaillierte Konfiguration und Nutzung siehe die [AI-Generierungsdokumentation](https://github.com/blessedrebus/krawl/blob/main/docs/ai_generation.md).
Du kannst auch **Täuschungsvorlagen beitragen**, indem du einen PR eröffnest, siehe [Beitragen von Täuschungsvorlagen](https://github.com/blessedrebus/krawl/blob/main/docs/deception_pages.md#contributing-deception-templates-via-pr).
## Betrieb hinter einem Reverse Proxy oder CDN
**NGINX, Traefik und andere Proxys wie CloudFlare** benötigen Header-Weiterleitung, damit Krawl die echte IP sehen kann. Siehe die [Reverse-Proxy-Dokumentation](https://github.com/blessedrebus/krawl/blob/main/docs/reverse-proxy.md) für Konfigurationsbeispiele und die vollständige Header-Liste.
## Metriken & Monitoring
Krawl stellt [Prometheus](https://prometheus.io/)-Metriken unter `/<dashboard_secret_path>/metrics` bereit (standardmäßig aktiviert) und wird mit einem importierfertigen [Grafana](https://grafana.com/)-Dashboard unter [`grafana-dashboard.json`](https://github.com/blessedrebus/krawl/blob/main/grafana-dashboard.json) geliefert.
Siehe die [Monitoring-Dokumentation](https://github.com/blessedrebus/krawl/blob/main/docs/monitoring.md) für die vollständige Metrikliste, Grafana-Importschritte und die Prometheus-/Kubernetes- (`ServiceMonitor`) Scraping-Einrichtung.
## Zusätzliche Dokumentation
| Thema | Beschreibung |
|-------|-------------|
| [AI-Generierung](https://github.com/blessedrebus/krawl/blob/main/docs/ai_generation.md) | KI-generierte Täuschungsseiten mit OpenRouter oder OpenAI konfigurieren |
| [Täuschungsseiten](https://github.com/blessedrebus/krawl/blob/main/docs/deception_pages.md) | Täuschungsseiten verwalten, importieren und exportieren; Massenvorgänge und datumsbasierte Filterung |
| [Bereitstellungsmodi](https://github.com/blessedrebus/krawl/blob/main/docs/deployment-modes.md) | Eigenständiger (SQLite) vs. skalierbarer (PostgreSQL + Redis) Modus, Konfiguration und Datenmigration |
| [Honeypot](https://github.com/blessedrebus/krawl/blob/main/docs/honeypot.md) | Vollständige Übersicht der Honeypot-Seiten: Fake-Logins, Verzeichnislisten, Anmeldedatendateien, SQLi/XSS/XXE/Command-Injection-Fallen und mehr |
| [Dashboard](https://github.com/blessedrebus/krawl/blob/main/docs/dashboard.md) | Zugriff auf das Echtzeit-Monitoring-Dashboard und dessen Erkundung |
| [Dashboard-API](https://github.com/blessedrebus/krawl/blob/main/docs/dashboard-api.md) | Krawls eigene JSON-API: Endpunkt-Referenz, Authentifizierung, interaktive OpenAPI-Dokumente und Anhangs-Downloads |
| [Externe APIs](https://github.com/blessedrebus/krawl/blob/main/docs/api.md) | Drittanbieter-APIs, die Krawl für IP-Daten, Reputation und Geolokalisierung aufruft |
| [Reverse Proxy](https://github.com/blessedrebus/krawl/blob/main/docs/reverse-proxy.md) | Bereitstellung von Krawl hinter NGINX oder Verwendung von Köder-Subdomains |
| [Datenbanksicherungen](https://github.com/blessedrebus/krawl/blob/main/docs/backups.md) | Automatischen Datenbank-Dump-Job aktivieren und konfigurieren |
| [Canary-Token](https://github.com/blessedrebus/krawl/blob/main/docs/canary-token.md) | Externe Alarmauslöser über canarytokens.org einrichten |
| [Wortliste](https://github.com/blessedrebus/krawl/blob/main/docs/wordlist.md) | Fake-Benutzernamen, Passwörter und Verzeichnislisten anpassen |
| [Architektur](https://github.com/blessedrebus/krawl/blob/main/docs/architecture.md) | Technische Übersicht der Codebasis, des Request-Pipelines, des Datenbankschemas und der Hintergrundaufgaben |
| [Cloudflare-Banlist-Synchronisierung](https://github.com/blessedrebus/krawl/blob/main/docs/cloudflare_banlist.md) | Überträgt gesperrte IPs von Krawl an eine Cloudflare-Konto-IP-Liste zur Verwendung in WAF-Regeln. Die Synchronisierung läuft als Hintergrundaufgabe und aktualisiert die Liste per vollständigem Ersatz. |
| [Firewall-Exporteure](https://github.com/blessedrebus/krawl/blob/main/docs/firewall-exporters.md) | IP-Banlisten im Roh-, iptables- oder nftables-Format über die REST-API exportieren |
| [Tarpit](https://github.com/blessedrebus/krawl/blob/main/docs/tarpit.md) | KI-Crawler mit verzögerten, rauschgefüllten Antworten verlangsamen und vergiften |
| [Metriken & Monitoring](https://github.com/blessedrebus/krawl/blob/main/docs/monitoring.md) | Prometheus-Metrik-Endpunkt, Referenz der bereitgestellten Metriken, Grafana-Dashboard und ServiceMonitor-Scraping |
## Mitwirken
Beiträge sind willkommen! Bitte:
1. Repository forken
2. Feature-Branch erstellen
3. Änderungen vornehmen
4. Pull-Request einreichen (Änderungen erklären!)
## Haftungsausschluss
> [!CAUTION]
> Dies ist ein Täuschungs-/Honeypot-System. In isolierten Umgebungen bereitstellen und sorgfältig auf Sicherheitsereignisse überwachen. Verantwortungsvoll und in Übereinstimmung mit geltenden Gesetzen und Vorschriften verwenden.
## Stern-Verlauf
<img src="https://star-history.dera.page/svg?repos=BlessedRebuS/Krawl&type=Date" width="600" alt="Star History Chart" />
| Standalone | Skalierbar |
|---|
| Datenbank | SQLite (WAL-Modus) | PostgreSQL |
| Cache | In-Memory-Python-Dict | Redis (mehrstufiger TTL) |
| Replikate | 1 (Einzelinstanz) | 1+ (horizontale Skalierung) |
| Externe Abhängigkeiten | Keine | PostgreSQL + Redis |
| Am besten geeignet für | Entwicklung, Homelabs, <500k Anfragen | Produktion, HA, >500k Anfragen |