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 darauf ausgelegt ist, bösartige Aktivitäten von Angreifern und Web-Crawlern über 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 dazu dient, bösartige Angreifer, Web-Crawler und automatisierte Scanner zu erkennen, zu verzögern und zu analysieren.
Er erstellt realistische, gefälschte Webanwendungen, gefüllt mit leicht zugänglichen Angriffszielen wie Admin-Panels, Konfigurationsdateien und offengelegten gefälschten 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 zusammen mit 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 unter einem zufälligen geheimen Pfad, der beim Start generiert wird, oder unter einem benutzerdefinierten Pfad, der über KRAWL_DASHBOARD_SECRET_PATH konfiguriert wird, erreichbar ist. Dies hält das Dashboard vor Angreifern verborgen, die deinen Honeypot scannen.
Das Dashboard ist in sechs Registerkarten gegliedert:
Zusätzlich werden nach Authentifizierung mit dem Dashboard-Passwort zwei geschützte Registerkarten 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 Anforderungszahlen. Keine zusätzliche Konfiguration erforderlich – einfach Krawl starten und es funktioniert.
Scalable: konzipiert 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. Sie hilft der Community, bekannte bösartige Akteure proaktiv zu blockieren, auch ohne Krawl zu verwenden.
Die Banlist kann auch direkt von folgender URL abgerufen werden: https://demo.krawlme.com/das_dashboard/api/export-ips?categories=attacker&fwtype=raw.
Krawl-Instanzen können ihre Banlisten föderieren: Jede Instanz kann ihre eigene Liste unter einem nicht authentifizierten Pfad veröffentlichen und Listen von anderen Instanzen (oder einer beliebigen Klartext-IP-Liste) abrufen. Die abgerufenen 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
## Schnellstart
### Docker Run
Starten Sie Krawl im Standalone-Modus mit dem neuesten Image:```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
Greife auf den Server unter http://localhost:5000 zu
Erstelle eine docker-compose.yaml mit einem der beiden Deployment-Modi.
Standalone: nur 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 Produktion gehen.**```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:
Zum Bereitstellen einfach ausführen```bash docker compose up -d
Produktionsreife Compose-Dateien sind ebenfalls im Verzeichnis [`docker/`](https://github.com/blessedrebus/krawl/blob/HEAD/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/HEAD/docker/dev/).
Weitere Einzelheiten zu beiden Modi finden Sie unter [Deployment Modes](https://github.com/blessedrebus/krawl/blob/HEAD/docs/deployment-modes.md).
### Kubernetes
**Krawl ist außerdem nativ auf Kubernetes verfügbar**. Die Installation kann entweder [per Manifest](https://github.com/blessedrebus/krawl/blob/HEAD/kubernetes/README.md) oder [mithilfe der Helm-Chart](https://github.com/blessedrebus/krawl/blob/HEAD/helm/README.md) erfolgen.
Die Helm-Chart **verwendet standardmäßig den skalierbaren Modus** mit gebündeltem PostgreSQL und Redis:```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
Minimale Beispielwerte-Dateien sind für beide Modi verfügbar:
values-minimal.yaml ---> Skalierbar (Standard)values-standalone.yaml ---> StandaloneSiehe Bereitstellungsmodi und Chart-Dokumentation für vollständige Konfigurations- und Migrationsanweisungen.
Führen Sie Krawl direkt mit Python 3.13+ und uvicorn für lokale Entwicklung oder Tests 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 schnelle Anpassungen ohne weitere Einrichtung empfohlen.
### Konfiguration über config.yaml
Sie können die Datei [config.yaml](https://github.com/blessedrebus/krawl/blob/HEAD/config.yaml) für erweiterte Konfigurationen verwenden, etwa 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 setzt sich aus `KRAWL_` plus dem Einstellungspfad in Großbuchstaben zusammen, so wird aus `dashboard.password` `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` | Server-Port, auf dem gelauscht wird | `5000` |
| `KRAWL_DELAY` | Antwortverzögerung in Millisekunden | `100` |
| `KRAWL_SERVER_HEADER` | HTTP-Server-Header zur 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` | Böswilligen IPs unendlich viele Seiten ausliefern | `true` |
| `KRAWL_MAX_PAGES_LIMIT` | Maximale Seitenbegrenzung für Crawler | `250` |
| `KRAWL_BAN_DURATION_SECONDS` | Sperrdauer in Sekunden für IPs mit Ratelimiting | `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` | Eigener 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 vorgewärmt werden | `10` |
| `KRAWL_DASHBOARD_WARMUP_AGGREGATION` | Vollständige top_paths/top_ua-Aggregationen vorberechnen für die Auslieferung ohne Datenbankabfragen | `false` |
| `KRAWL_DASHBOARD_TOP_N_MIN_COUNT` | Mindestanzahl an Zugriffen für die Panels „Top-Pfade/Benutzeragenten“ (auf 1 setzen, um zu deaktivieren) | `5` |
| `KRAWL_METRICS_ENABLED` | Prometheus-Metriken unter `/<dashboard_path>/metrics` bereitstellen | `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` | Anzahl der 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-Zeitplans | `*/30 * * * *` |
| `KRAWL_BACKUPS_ENABLED` | Boolescher Wert zum Aktivieren des Datenbank-Dump-Jobs | `true` |
</details>
<details>
<summary><b>Fallensysteme: Tarpit, Täuschungsseiten und Canary</b> (6 Variablen)</summary>
Optionale Fallensysteme und die Seiten, die Angreifern ausgeliefert werden.
| Umgebungsvariable | Beschreibung | Standard |
|----------------------|-------------|---------|
| `KRAWL_TARPIT_ENABLED` | KI-Agenten mit langsamen Antworten und zufälligem Text fangen | `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 der Canary-Token angezeigt wird | `10` |
</details>
<details>
<summary><b>IP-Reputationsanalysator</b> (6 Variablen)</summary>
Schwellenwerte, die darüber entscheiden, 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 zur 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 Verkehr, der niemals verfolgt wird.
| Umgebungsvariable | Beschreibung | Standard |
|----------------------|-------------|---------|
| `KRAWL_IGNORED_IPS` | Kommagetrennte IPs/CIDRs, die niemals 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, die abgerufen und zusammengeführt werden | Krawl-Community-Sperrliste |
| `KRAWL_BANLIST_REFRESH_INTERVAL` | Sekunden zwischen dem Abruf der Upstream-Sperrlisten | `3600` |
</details>
<details>
<summary><b>KI-generierte Täuschungsseiten</b> (10 Variablen)</summary>
Siehe die [KI-Generierungsdokumentation](https://github.com/blessedrebus/krawl/blob/HEAD/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 | `Keine` |
| `KRAWL_AI_MODEL` | KI-Modell für die Seitengenerierung | `"nvidia/nemotron-3-super-120b-a12b:free"` |
| `KRAWL_AI_TIMEOUT` | Anfragetimeout 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` ist. Siehe [Bereitstellungsmodi](https://github.com/blessedrebus/krawl/blob/HEAD/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 | Keine |
| `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
## Mit Krawl bösartige IPs sperren
Krawl verwendet ein reputationsbasiertes System, um Angreifer-IP-Adressen 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`) und 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:
Vollständige API-Parameter, Beispiele und das Hinzufügen eigener Firewall-Formate finden Sie in der Dokumentation zu Firewall-Exporten.
Krawl kann gebannte IPs außerdem direkt in eine Cloudflare Account IP List übertragen, um sie in WAF-Regeln zu verwenden. Die Synchronisierung läuft als Hintergrundaufgabe und aktualisiert die Liste in einem konfigurierbaren Intervall per vollständigem Austausch. Siehe die Dokumentation zur Cloudflare-Banlist-Synchronisierung.
Krawl verwendet Aufgaben, die den aktuellen Datenverkehr analysieren, um eine IP-Reputation aufzubauen und kontinuierlich zu aktualisieren. Diese läuft periodisch und bewertet jede aktive IP-Adresse anhand mehrerer verhaltensbasierter Indikatoren, um sie als Angreifer, Crawler oder normalen Benutzer zu klassifizieren. Die 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 Gegenmaßnahmen wie IP-Sperrung oder Firewall-Integration zu steuern.
Krawl kann mithilfe von KI-Modellen der OpenRouter- oder OpenAI-APIs automatisch realistische Täuschungsseiten erstellen. Diese Funktion generiert spontan einzigartige, plausible Honeypot-Seiten, um Angreifer zu täuschen, ohne dass Seiten manuell erstellt werden müssen.
Hauptfunktionen:
Schnelleinrichtung:```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 [KI-Generierungsdokumentation](https://github.com/blessedrebus/krawl/blob/HEAD/docs/ai_generation.md).
Du kannst auch **Deception-Vorlagen beisteuern**, indem du einen PR eröffnest, siehe [Deception-Vorlagen beisteuern](https://github.com/blessedrebus/krawl/blob/HEAD/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-Adresse sehen kann. Siehe die [Reverse-Proxy-Dokumentation](https://github.com/blessedrebus/krawl/blob/HEAD/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 importbereiten [Grafana](https://grafana.com/)-Dashboard unter [`grafana-dashboard.json`](https://github.com/blessedrebus/krawl/blob/HEAD/grafana-dashboard.json) geliefert.
Siehe die [Monitoring-Dokumentation](https://github.com/blessedrebus/krawl/blob/HEAD/docs/monitoring.md) für die vollständige Metrikliste, Grafana-Importschritte und das Prometheus-/Kubernetes-Scraping-Setup (`ServiceMonitor`).
## Weitere Dokumentation
| Thema | Beschreibung |
|-------|-------------|
| [KI-Generierung](https://github.com/blessedrebus/krawl/blob/HEAD/docs/ai_generation.md) | Konfiguriere KI-generierte Deception-Seiten mit OpenRouter oder OpenAI |
| [Deception-Seiten](https://github.com/blessedrebus/krawl/blob/HEAD/docs/deception_pages.md) | Verwalte, importiere und exportiere Deception-Seiten; Massenvorgänge und datumsbasierte Filterung |
| [Bereitstellungsmodi](https://github.com/blessedrebus/krawl/blob/HEAD/docs/deployment-modes.md) | Standalone-Modus (SQLite) vs. skalierbarer Modus (PostgreSQL + Redis), Konfiguration und Datenmigration |
| [Honeypot](https://github.com/blessedrebus/krawl/blob/HEAD/docs/honeypot.md) | Vollständige Übersicht über Honeypot-Seiten: gefälschte Logins, Verzeichnislisten, Anmeldedaten-Dateien, SQLi-/XSS-/XXE-/Command-Injection-Fallen und mehr |
| [Dashboard](https://github.com/blessedrebus/krawl/blob/HEAD/docs/dashboard.md) | Zugriff auf das Echtzeit-Monitoring-Dashboard und dessen Erkundung |
| [Dashboard-API](https://github.com/blessedrebus/krawl/blob/HEAD/docs/dashboard-api.md) | Krawls eigene JSON-API: Endpunkt-Referenz, Authentifizierung, interaktive OpenAPI-Dokumentation und Anhangs-Downloads |
| [Externe APIs](https://github.com/blessedrebus/krawl/blob/HEAD/docs/api.md) | Drittanbieter-APIs, die Krawl für IP-Daten, Reputation und Geolokalisierung aufruft |
| [Reverse-Proxy](https://github.com/blessedrebus/krawl/blob/HEAD/docs/reverse-proxy.md) | So stellst du Krawl hinter NGINX bereit oder verwendest Köder-Subdomains |
| [Datenbank-Backups](https://github.com/blessedrebus/krawl/blob/HEAD/docs/backups.md) | Aktiviere und konfiguriere den automatischen Datenbank-Dump-Job |
| [Canary-Token](https://github.com/blessedrebus/krawl/blob/HEAD/docs/canary-token.md) | Richte externe Alarm-Trigger über canarytokens.org ein |
| [Wortliste](https://github.com/blessedrebus/krawl/blob/HEAD/docs/wordlist.md) | Passe gefälschte Benutzernamen, Passwörter und Verzeichnislisten an |
| [Architektur](https://github.com/blessedrebus/krawl/blob/HEAD/docs/architecture.md) | Technische Übersicht über Codebasis, Request-Pipeline, Datenbankschema und Hintergrundaufgaben |
| [Cloudflare-Banlist-Sync](https://github.com/blessedrebus/krawl/blob/HEAD/docs/cloudflare_banlist.md) | Überträgt gesperrte IPs von Krawl in eine Cloudflare-Account-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/HEAD/docs/firewall-exporters.md) | Exportiere IP-Sperrlisten im Raw-, iptables- oder nftables-Format über die REST-API |
| [Tarpit](https://github.com/blessedrebus/krawl/blob/HEAD/docs/tarpit.md) | Verlangsame und vergifte KI-Crawler mit verzögerten, mit Rauschen aufgefüllten Antworten |
| [Metriken & Monitoring](https://github.com/blessedrebus/krawl/blob/HEAD/docs/monitoring.md) | Prometheus-Metriken-Endpunkt, Referenz der bereitgestellten Metriken, Grafana-Dashboard und ServiceMonitor-Scraping |
## Mitwirken
Beiträge sind willkommen! Bitte:
1. Forke das Repository
2. Erstelle einen Feature-Branch
3. Nimm deine Änderungen vor
4. Reiche einen Pull-Request ein (erkläre die Änderungen!)
## Haftungsausschluss
> [!CAUTION]
> Dies ist ein Deception-/Honeypot-System. Setze es in isolierten Umgebungen ein und überwache es sorgfältig auf Sicherheitsereignisse. Verwende es verantwortungsvoll und in Übereinstimmung mit geltenden Gesetzen und Vorschriften.
## Star-Historie
<img src="https://star-history.dera.page/svg?repos=BlessedRebuS/Krawl&type=Date" width="600" alt="Diagramm der Star-Historie" />
| Standalone | Scalable |
|---|
| 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 | Dev, Homelabs, <500k Anfragen | Produktion, HA, >500k Anfragen |