blessedrebus/krawlKrawl è un server di deception web personalizzabile, leggero e nativo del cloud, e un anti-crawler che crea applicazioni web false con vulnerabilità di bassa complessità utilizzando dati esca realistici generati casualmente e template HTML generati dall'IA.
Un server web honeypot moderno e personalizzabile, progettato per rilevare e tracciare attività dannose da parte di attaccanti e crawler web tramite pagine web ingannevoli, credenziali finte e canary token.
Suggerimento: esplora i percorsi di robots.txt per divertirti di più
Krawl è un server di inganno cloud‑native progettato per rilevare, rallentare e analizzare attaccanti dannosi, crawler web e scanner automatizzati.
Crea applicazioni web finte e realistiche piene di "frutti a portata di mano" come pannelli di amministrazione, file di configurazione e credenziali finte esposte, per attirare e identificare attività sospette.
Sprecando le risorse degli attaccanti, Krawl aiuta a distinguere chiaramente il comportamento dannoso dai crawler legittimi.
Include:
Puoi facilmente esporre Krawl insieme ai tuoi altri servizi per proteggerli da crawler web e utenti dannosi tramite un reverse proxy. Per maggiori dettagli, consulta la documentazione sul Reverse Proxy.
Krawl fornisce una dashboard completa, accessibile tramite un percorso segreto casuale generato all'avvio o tramite un percorso personalizzato configurato con KRAWL_DASHBOARD_SECRET_PATH. Questo mantiene la dashboard nascosta agli attaccanti che scansionano il tuo honeypot.
La dashboard è organizzata in sei schede:
Inoltre, dopo l'autenticazione con la password della dashboard, diventano disponibili due schede protette:
Per maggiori dettagli, consulta la documentazione sulla Dashboard.
Krawl supporta due modalità di distribuzione, controllate dall'impostazione mode in config.yaml o dalla variabile d'ambiente KRAWL_MODE.
Standalone: ideale per ambienti di sviluppo o homelab con volumi di richieste bassi. Nessuna configurazione aggiuntiva necessaria: basta eseguire Krawl e funziona.
Scalabile: progettato per ambienti di produzione o honeypot ad alto traffico. Il chart Helm utilizza questa modalità come predefinita.
Per una configurazione dettagliata, esempi Docker Compose, setup Kubernetes/Helm e istruzioni di migrazione passo-passo, consulta la documentazione sulle Modalità di distribuzione.
Krawl mantiene una banlist.txt aggiornata regolarmente con gli indirizzi IP degli attaccanti che hanno attivato le sue trappole honeypot. La banlist viene pubblicata settimanalmente ed è disponibile per il download, aiutando la community a bloccare preventivamente attori dannosi noti anche senza usare Krawl.
La banlist può anche essere scaricata direttamente da: https://demo.krawlme.com/das_dashboard/api/export-ips?categories=attacker&fwtype=raw.
Le istanze di Krawl possono federare le proprie banlist: ciascuna può pubblicare la propria lista su un percorso non autenticato e importare liste da altre istanze (o qualsiasi lista IP in testo semplice). Gli IP importati vengono integrati nelle decisioni di ban locali e mostrati nella dashboard.```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 Run
Esegui Krawl in modalità standalone con l'ultima immagine:```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
Accedi al server su http://localhost:5000
Crea un docker-compose.yaml con una delle due modalità di distribuzione.
Standalone: solo il server Krawl con archiviazione 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:
**Scalabile**: con PostgreSQL e Redis:
> [!CAUTION]
> L'esempio seguente utilizza **password predefinite** (`krawl`/`krawl`). **Modificale prima di distribuire in produzione.**```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:
Per distribuire, basta eseguire```bash docker compose up -d
File compose pronti per la produzione sono disponibili anche nella directory [`docker/`](https://github.com/blessedrebus/krawl/blob/main/docker). Per lo **sviluppo** (build dal sorgente con hot-reload), usa i file compose in [`docker/dev/`](https://github.com/blessedrebus/krawl/blob/main/docker/dev).
Per maggiori dettagli su entrambe le modalità, consulta [Modalità di Deployment](https://github.com/blessedrebus/krawl/blob/main/docs/deployment-modes.md).
### Kubernetes
**Krawl è disponibile anche nativamente su Kubernetes**. L'installazione può essere effettuata [tramite manifest](https://github.com/blessedrebus/krawl/blob/main/kubernetes/README.md) oppure [usando il chart Helm](https://github.com/blessedrebus/krawl/blob/main/helm/README.md).
Il chart Helm **predefinisce la modalità scalabile** con PostgreSQL e Redis inclusi:```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
File di esempio con valori minimi sono forniti per entrambe le modalità:
values-minimal.yaml ---> Scalabile (predefinita)values-standalone.yaml ---> StandaloneConsulta Modalità di distribuzione e Documentazione del chart per la configurazione completa e le istruzioni di migrazione.
Esegui Krawl direttamente con Python 3.13+ e uvicorn per lo sviluppo locale o i test:```bash pip install -r requirements.txt uvicorn app:app --host 0.0.0.0 --port 5000 --app-dir src --no-server-header
Accedi al server su `http://localhost:5000`
## Configurazione
Krawl utilizza una **gerarchia di configurazione** in cui **le variabili d'ambiente hanno precedenza sul file di configurazione**. Questo approccio è consigliato per distribuzioni Docker e per una personalizzazione rapida e immediata.
### Configurazione tramite config.yaml
Puoi utilizzare il file [config.yaml](https://github.com/blessedrebus/krawl/blob/main/config.yaml) per configurazioni avanzate, come distribuzioni con Docker Compose o chart Helm.
### Configurazione tramite variabili d'ambiente
Tutte le impostazioni possono essere fornite come variabili d'ambiente, che sovrascrivono `config.yaml`.
Il nome della variabile è `KRAWL_` più il percorso dell'impostazione in maiuscolo, quindi `dashboard.password`
diventa `KRAWL_DASHBOARD_PASSWORD`.
<details>
<summary><b>Server e generazione dei link</b> (12 variabili)</summary>
Come Krawl si presenta e modella il labirinto delle pagine generate.
| Variabile d'ambiente | Descrizione | Predefinito |
|----------------------|-------------|---------|
| `CONFIG_LOCATION` | Percorso del file di configurazione yaml | `config.yaml` |
| `KRAWL_PORT` | Porta di ascolto del server | `5000` |
| `KRAWL_DELAY` | Ritardo di risposta in millisecondi | `100` |
| `KRAWL_SERVER_HEADER` | Intestazione HTTP Server per l'inganno | `""` |
| `KRAWL_LINKS_LENGTH_RANGE` | Intervallo di lunghezza dei link come `min,max` | `5,15` |
| `KRAWL_LINKS_PER_PAGE_RANGE` | Link per pagina come `min,max` | `10,15` |
| `KRAWL_CHAR_SPACE` | Caratteri utilizzati per la generazione dei link | `abcdefgh...` |
| `KRAWL_MAX_COUNTER` | Valore iniziale del contatore | `10` |
| `KRAWL_PROBABILITY_ERROR_CODES` | Probabilità di risposta di errore (0-100%) | `0` |
| `KRAWL_INFINITE_PAGES_FOR_MALICIOUS` | Servi pagine infinite agli IP dannosi | `true` |
| `KRAWL_MAX_PAGES_LIMIT` | Limite massimo di pagine per i crawler | `250` |
| `KRAWL_BAN_DURATION_SECONDS` | Durata del ban in secondi per gli IP soggetti a rate limiting | `600` |
</details>
<details>
<summary><b>Dashboard, metriche e logging</b> (8 variabili)</summary>
Accesso alla dashboard, warmup della cache, Prometheus e livello di log.
| Variabile d'ambiente | Descrizione | Predefinito |
|----------------------|-------------|---------|
| `KRAWL_DASHBOARD_SECRET_PATH` | Percorso personalizzato della dashboard | Generato automaticamente |
| `KRAWL_DASHBOARD_PASSWORD` | Password per i pannelli protetti della dashboard | Generata automaticamente |
| `KRAWL_DASHBOARD_CACHE_WARMUP` | Pre-calcola i dati della dashboard ogni 5 minuti per caricamenti istantanei delle pagine | `true` |
| `KRAWL_DASHBOARD_WARMUP_PAGES` | Numero di pagine da pre-caricare per pannello tabellare | `10` |
| `KRAWL_DASHBOARD_WARMUP_AGGREGATION` | Pre-calcola le aggregazioni complete top_paths/top_ua per un servizio senza query | `false` |
| `KRAWL_DASHBOARD_TOP_N_MIN_COUNT` | Conteggio minimo di accessi per i pannelli dei percorsi/user agent principali (impostare a 1 per disabilitare) | `5` |
| `KRAWL_METRICS_ENABLED` | Espone le metriche Prometheus su `/<dashboard_path>/metrics` | `true` |
| `KRAWL_LOG_LEVEL` | Livello di log dell'applicazione (`DEBUG`, `INFO`, `WARNING`, `ERROR`) | `INFO` |
</details>
<details>
<summary><b>Database, conservazione e backup</b> (6 variabili)</summary>
Posizione di archiviazione, durata di conservazione dei dati e job di dump.
| Variabile d'ambiente | Descrizione | Predefinito |
|----------------------|-------------|---------|
| `KRAWL_DATABASE_PATH` | Posizione del file del database | `data/krawl.db` |
| `KRAWL_DATABASE_PERSIST_SUSPICIOUS_ONLY` | Persisti solo le richieste sospette nel log degli accessi | `false` |
| `KRAWL_DATABASE_RETENTION_DAYS` | Giorni di conservazione dei dati nel database | `30` |
| `KRAWL_BACKUPS_PATH` | Percorso in cui vengono salvati i dump del database | `backups` |
| `KRAWL_BACKUPS_CRON` | Espressione cron per controllare la pianificazione del job di backup | `*/30 * * * *` |
| `KRAWL_BACKUPS_ENABLED` | Booleano per abilitare il job di dump del database | `true` |
</details>
<details>
<summary><b>Trappole: tarpit, pagine di inganno e canary</b> (6 variabili)</summary>
Trappole opzionali e pagine servite agli attaccanti.
| Variabile d'ambiente | Descrizione | Predefinito |
|----------------------|-------------|---------|
| `KRAWL_TARPIT_ENABLED` | Intrappola gli agenti AI con risposte lente e testo casuale | `false` |
| `KRAWL_TARPIT_DELAY_SECONDS` | Ritardo extra in secondi aggiunto per risposta quando il tarpit è attivo | `5` |
| `KRAWL_DECEPTION_IMPORT_PAGES` | Importa automaticamente le pagine di inganno da `src/templates/deception/` all'avvio | `true` |
| `KRAWL_CUSTOM_TEMPLATE_PATH` | Percorso all'interno del container per un template HTML personalizzato. Il template deve includere i segnaposto `{counter}` e `{content}`. | `/templates/custom_page.html` |
| `KRAWL_CANARY_TOKEN_URL` | URL esterno del token canary | Nessuno |
| `KRAWL_CANARY_TOKEN_TRIES` | Richieste prima di mostrare il token canary | `10` |
</details>
<details>
<summary><b>Analizzatore di reputazione IP</b> (6 variabili)</summary>
Soglie che determinano come viene classificato un IP.
| Variabile d'ambiente | Descrizione | Predefinito |
|----------------------|-------------|---------|
| `KRAWL_HTTP_RISKY_METHODS_THRESHOLD` | Soglia per il rilevamento di metodi HTTP rischiosi | `0.1` |
| `KRAWL_VIOLATED_ROBOTS_THRESHOLD` | Soglia per le violazioni di robots.txt | `0.1` |
| `KRAWL_UNEVEN_REQUEST_TIMING_THRESHOLD` | Soglia del coefficiente di variazione per la temporizzazione | `0.5` |
| `KRAWL_UNEVEN_REQUEST_TIMING_TIME_WINDOW_SECONDS` | Finestra temporale per l'analisi della temporizzazione delle richieste in secondi | `300` |
| `KRAWL_USER_AGENTS_USED_THRESHOLD` | Soglia per il rilevamento di più user agent | `2` |
| `KRAWL_ATTACK_URLS_THRESHOLD` | Soglia per il rilevamento di URL di attacco | `1` |
</details>
<details>
<summary><b>Banlist e IP ignorati</b> (4 variabili)</summary>
Condivisione delle banlist con altre istanze e traffico da non tracciare mai.
| Variabile d'ambiente | Descrizione | Predefinito |
|----------------------|-------------|---------|
| `KRAWL_IGNORED_IPS` | IP/CIDR separati da virgole mai tracciati, bannati o esportati | Loopback, RFC1918, link-local, CGNAT |
| `KRAWL_BANLIST_EXPORT_PATH` | Percorso pubblico di download della banlist, es. `/public_banlist.txt` (vuoto = disabilitato) | `""` |
| `KRAWL_BANLIST_SOURCES` | URL di banlist upstream separati da virgole da recuperare e unire | Banlist community di Krawl |
| `KRAWL_BANLIST_REFRESH_INTERVAL` | Secondi tra i recuperi delle banlist upstream | `3600` |
</details>
<details>
<summary><b>Pagine di inganno generate dall'AI</b> (10 variabili)</summary>
Consulta la [documentazione sulla generazione AI](https://github.com/blessedrebus/krawl/blob/main/docs/ai_generation.md).
| Variabile d'ambiente | Descrizione | Predefinito |
|----------------------|-------------|---------|
| `KRAWL_AI_ENABLED` | Abilita le pagine di inganno generate dall'AI | `false` |
| `KRAWL_AI_PROVIDER` | Provider AI (`"openrouter"` o `"openai"`) | `"openrouter"` |
| `KRAWL_AI_OPENAI_BASE_URL` | URL di base OpenAI opzionale per endpoint API personalizzati | `"https://api.openai.com/v1"` |
| `KRAWL_AI_API_KEY` | Chiave API per il provider AI | `None` |
| `KRAWL_AI_MODEL` | Modello AI da utilizzare per la generazione delle pagine | `"nvidia/nemotron-3-super-120b-a12b:free"` |
| `KRAWL_AI_TIMEOUT` | Timeout della richiesta in secondi per le chiamate API AI | `60` |
| `KRAWL_AI_MAX_DAILY_REQUESTS` | Numero massimo di pagine generate dall'AI al giorno (0 = illimitato) | `0` |
| `KRAWL_AI_PROMPT` | Template di prompt personalizzato per la generazione di pagine AI | Prompt predefinito |
| `KRAWL_AI_REASONING_ENABLED` | Abilita i token di ragionamento (solo modelli di ragionamento OpenRouter) | `false` |
| `KRAWL_AI_REASONING_EFFORT` | Sforzo di ragionamento (`none`, `minimal`, `low`, `medium`, `high`, `xhigh`) | `"medium"` |
</details>
<details>
<summary><b>Modalità scalabile: PostgreSQL e Redis</b> (13 variabili)</summary>
Utilizzate solo quando `KRAWL_MODE=scalable`. Consulta [Modalità di distribuzione](https://github.com/blessedrebus/krawl/blob/main/docs/deployment-modes.md).
| Variabile d'ambiente | Descrizione | Predefinito |
|----------------------|-------------|---------|
| `KRAWL_MODE` | Modalità di distribuzione (`standalone` o `scalable`) | `standalone` |
| `KRAWL_POSTGRES_HOST` | Hostname PostgreSQL | `localhost` |
| `KRAWL_POSTGRES_PORT` | Porta PostgreSQL | `5432` |
| `KRAWL_POSTGRES_USER` | Nome utente PostgreSQL | `krawl` |
| `KRAWL_POSTGRES_PASSWORD` | Password PostgreSQL | `krawl` |
| `KRAWL_POSTGRES_DATABASE` | Nome del database PostgreSQL | `krawl` |
| `KRAWL_REDIS_HOST` | Hostname Redis | `localhost` |
| `KRAWL_REDIS_PORT` | Porta Redis | `6379` |
| `KRAWL_REDIS_DB` | Numero del database Redis | `0` |
| `KRAWL_REDIS_PASSWORD` | Password Redis | None |
| `KRAWL_REDIS_CACHE_TTL` | TTL in secondi per i dati di warmup della dashboard | `600` |
| `KRAWL_REDIS_HOT_TTL` | TTL in secondi per i dati hot-path (info ban, categorie IP) | `30` |
| `KRAWL_REDIS_TABLE_TTL` | TTL in secondi per le tabelle dashboard paginate | `120` |
</details>
Ad esempio```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"
Esempio di esecuzione Docker con variabili d'ambiente (modalità standalone):```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
## Usa Krawl per Bannare IP Maliziosi
Krawl utilizza un sistema basato sulla reputazione per classificare gli indirizzi IP degli attaccanti e fornisce due modi per esportare elenchi di IP per l'integrazione con il firewall.
L'endpoint `/api/export-ips` interroga direttamente il database e supporta il filtraggio per categoria di IP (`attacker`, `bad_crawler`, `regular_user`, `good_crawler`) e formato di output (`raw`, `iptables`, `nftables`):```bash
curl "https://your-krawl-instance/<DASHBOARD-PATH>/api/export-ips?categories=attacker&fwtype=raw"
Questo consente il blocco automatico del traffico dannoso su diverse piattaforme:
Per tutti i parametri API, gli esempi e l'aggiunta di formati firewall personalizzati, consulta la documentazione Firewall Exporters.
Krawl può anche inviare direttamente gli IP bannati a una Cloudflare Account IP List per l'uso nelle regole WAF. La sincronizzazione viene eseguita come attività in background e aggiorna l'elenco tramite sostituzione completa a intervalli configurabili. Consulta la documentazione Cloudflare Banlist Sync.
Krawl utilizza attività che analizzano il traffico recente per costruire e aggiornare continuamente un punteggio di reputazione IP. Viene eseguito periodicamente e valuta ogni indirizzo IP attivo sulla base di molteplici indicatori comportamentali per classificarlo come attaccante, crawler o utente regolare. Le soglie sono completamente personalizzabili.
L'analisi include:
Ogni segnale contribuisce a un modello di punteggio ponderato che assegna una categoria di reputazione:
attackerbad_crawlergood_crawlerregular_userunknown (per dati insufficienti)I punteggi e le metriche risultanti vengono memorizzati nel database e utilizzati da Krawl per alimentare dashboard, monitoraggio della reputazione e azioni di mitigazione automatizzate come il ban degli IP o l'integrazione con il firewall.
Krawl può generare automaticamente pagine di deception realistiche utilizzando modelli IA delle API OpenRouter o OpenAI. Questa funzionalità crea pagine honeypot uniche e plausibili al volo per ingannare gli attaccanti senza creazione manuale delle pagine.
Caratteristiche principali:
Configurazione rapida:```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
Per la configurazione dettagliata e l'utilizzo, consulta la [documentazione sulla generazione AI](https://github.com/blessedrebus/krawl/blob/main/docs/ai_generation.md).
Puoi anche **contribuire con template di deception** aprendo una PR, vedi [Contribuire con Template di Deception](https://github.com/blessedrebus/krawl/blob/main/docs/deception_pages.md#contributing-deception-templates-via-pr).
## Esecuzione dietro un Reverse Proxy o CDN
**NGINX, Traefik e altri proxy come CloudFlare** necessitano dell'inoltro degli header affinché Krawl possa vedere l'IP reale. Consulta la [documentazione sul Reverse Proxy](https://github.com/blessedrebus/krawl/blob/main/docs/reverse-proxy.md) per esempi di configurazione e l'elenco completo degli header.
## Metriche e Monitoraggio
Krawl espone metriche [Prometheus](https://prometheus.io/) su `/<dashboard_secret_path>/metrics` (abilitate per impostazione predefinita) e include una dashboard [Grafana](https://grafana.com/) pronta per l'importazione in [`grafana-dashboard.json`](https://github.com/blessedrebus/krawl/blob/main/grafana-dashboard.json).
Consulta la [documentazione sul Monitoraggio](https://github.com/blessedrebus/krawl/blob/main/docs/monitoring.md) per l'elenco completo delle metriche, i passaggi per l'importazione in Grafana e la configurazione dello scraping Prometheus / Kubernetes (`ServiceMonitor`).
## Documentazione Aggiuntiva
| Argomento | Descrizione |
|-------|-------------|
| [Generazione AI](https://github.com/blessedrebus/krawl/blob/main/docs/ai_generation.md) | Configura pagine di deception generate dall'AI usando OpenRouter o OpenAI |
| [Pagine di Deception](https://github.com/blessedrebus/krawl/blob/main/docs/deception_pages.md) | Gestisci, importa ed esporta pagine di deception; operazioni bulk e filtri basati sulla data |
| [Modalità di Distribuzione](https://github.com/blessedrebus/krawl/blob/main/docs/deployment-modes.md) | Modalità Standalone (SQLite) vs Scalabile (PostgreSQL + Redis), configurazione e migrazione dei dati |
| [Honeypot](https://github.com/blessedrebus/krawl/blob/main/docs/honeypot.md) | Panoramica completa delle pagine honeypot: login falsi, elenchi di directory, file di credenziali, trappole SQLi/XSS/XXE/command injection e altro |
| [Dashboard](https://github.com/blessedrebus/krawl/blob/main/docs/dashboard.md) | Accedi ed esplora la dashboard di monitoraggio in tempo reale |
| [API della Dashboard](https://github.com/blessedrebus/krawl/blob/main/docs/dashboard-api.md) | API JSON di Krawl: riferimento degli endpoint, autenticazione, documentazione OpenAPI interattiva e download degli allegati |
| [API Esterne](https://github.com/blessedrebus/krawl/blob/main/docs/api.md) | API di terze parti a cui Krawl si rivolge per dati IP, reputazione e geolocalizzazione |
| [Reverse Proxy](https://github.com/blessedrebus/krawl/blob/main/docs/reverse-proxy.md) | Come distribuire Krawl dietro NGINX o utilizzare sottodomini esca |
| [Backup del Database](https://github.com/blessedrebus/krawl/blob/main/docs/backups.md) | Abilita e configura il job automatico di dump del database |
| [Canary Token](https://github.com/blessedrebus/krawl/blob/main/docs/canary-token.md) | Configura trigger di allerta esterni tramite canarytokens.org |
| [Wordlist](https://github.com/blessedrebus/krawl/blob/main/docs/wordlist.md) | Personalizza nomi utente, password ed elenchi di directory falsi |
| [Architettura](https://github.com/blessedrebus/krawl/blob/main/docs/architecture.md) | Panoramica tecnica del codebase, pipeline delle richieste, schema del database e attività in background |
| [Sincronizzazione Banlist Cloudflare](https://github.com/blessedrebus/krawl/blob/main/docs/cloudflare_banlist.md) | Invia gli IP bannati da Krawl a una Cloudflare Account IP List per l'uso nelle regole WAF. La sincronizzazione viene eseguita come attività in background e aggiorna l'elenco tramite sostituzione completa. |
| [Esportatori Firewall](https://github.com/blessedrebus/krawl/blob/main/docs/firewall-exporters.md) | Esporta le banlist IP in formato raw, iptables o nftables tramite API REST |
| [Tarpit](https://github.com/blessedrebus/krawl/blob/main/docs/tarpit.md) | Rallenta e avvelena i crawler AI con risposte ritardate e riempite di rumore |
| [Metriche e Monitoraggio](https://github.com/blessedrebus/krawl/blob/main/docs/monitoring.md) | Endpoint delle metriche Prometheus, riferimento delle metriche esposte, dashboard Grafana e scraping ServiceMonitor |
## Contribuire
Contributi benvenuti! Per favore:
1. Fai un fork del repository
2. Crea un branch per la funzionalità
3. Apporta le tue modifiche
4. Invia una pull request (spiega le modifiche!)
## Disclaimer
> [!CAUTION]
> Questo è un sistema di deception/honeypot. Distribuiscilo in ambienti isolati e monitoralo attentamente per eventi di sicurezza. Usalo in modo responsabile e in conformità con le leggi e i regolamenti applicabili.
## Cronologia delle Stelle
<img src="https://star-history.dera.page/svg?repos=BlessedRebuS/Krawl&type=Date" width="600" alt="Grafico della Cronologia delle Stelle" />
| Standalone | Scalabile |
|---|
| Database | SQLite (modalità WAL) | PostgreSQL |
| Cache | Dizionario Python in memoria | Redis (TTL multi-livello) |
| Repliche | 1 (istanza singola) | 1+ (scalabilità orizzontale) |
| Dipendenze esterne | Nessuna | PostgreSQL + Redis |
| Ideale per | Sviluppo, homelab, <500k richieste | Produzione, HA, >500k richieste |