Torna agli aggiornamenti
New releaseAug 21, 2026

Krawl v2.3.0

Krawl è 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.

Condividi

Krawl

Un server honeypot web moderno e personalizzabile progettato per rilevare e tracciare l'attività dannosa di attaccanti e crawler web tramite pagine web ingannevoli, credenziali false e canary token.

Indice

Demo

Suggerimento: esplora i percorsi di robots.txt per un divertimento in più

URL di Krawl: http://demo.krawlme.com

Visualizza la dashboard http://demo.krawlme.com/das_dashboard

Cos'è Krawl?

Krawl è un server di deception cloud-native progettato per rilevare, rallentare e analizzare attaccanti malintenzionati, crawler web e scanner automatizzati.

Crea applicazioni web finte e realistiche piene di facili prede come pannelli di amministrazione, file di configurazione e credenziali false esposte per attirare e identificare attività sospette.

dashboard

Facendo sprecare risorse agli attaccanti, Krawl aiuta a distinguere chiaramente il comportamento dannoso dai crawler legittimi.

Funzionalità:

  • Pagine di Deception Generate da IA: Lascia che siano gli attaccanti a generare la tua superficie d'attacco finta e vulnerabile
  • Pagine Trappola per Spider: infiniti link casuali per sprecare le risorse dei crawler, basati sul progetto spidertrap
  • Pagine di Login Finte: WordPress, phpMyAdmin, pannelli di amministrazione
  • Percorsi Honeypot: pubblicizzati in robots.txt per catturare gli scanner
  • Credenziali False: nomi utente, password e chiavi API dall'aspetto realistico
  • Integrazione con Canary Token: attivazione di avvisi esterni
  • Header del server casuali: confonde gli attaccanti in base all'header e alla versione del server
  • Dashboard in tempo reale: monitora l'attività sospetta
  • Wordlist personalizzabili: configurazione semplice basata su JSON
  • Iniezione di errori casuali: imita il comportamento reale del server

Puoi esporre facilmente Krawl insieme ai tuoi altri servizi per proteggerli da crawler web e utenti malintenzionati usando un reverse proxy. Per maggiori dettagli, consulta la documentazione sul Reverse Proxy.

use case

Dashboard di Krawl

Krawl offre una dashboard completa, accessibile tramite un percorso segreto casuale generato all'avvio oppure 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:

  • Panoramica: visione di alto livello dell'attività degli attacchi: una mappa interattiva delle origini degli IP, richieste sospette recenti e i principali IP, User-Agent e percorsi.

geoip

  • Attacchi: ripartizione dettagliata delle credenziali catturate, delle attivazioni honeypot e dei tipi di attacco rilevati (SQLi, XSS, path traversal, ecc.) con grafici e tabelle.

attack_types

  • IP Insight: visione forense approfondita di un IP selezionato: geolocalizzazione, informazioni ISP/ASN, flag di reputazione, timeline comportamentale, distribuzione dei tipi di attacco e cronologia completa degli accessi.

ipinsight

Inoltre, dopo l'autenticazione con la password della dashboard, sono disponibili due schede protette:

  • IP Tracciati: mantieni una watchlist di indirizzi IP da monitorare nel tempo.
  • IP Banlist: gestisci i ban IP, visualizza gli attaccanti rilevati ed esporta la banlist in formato raw o IPTables.
  • Deception: gestisci le pagine generate dall'IA, esportale o importane di nuove.

Per maggiori dettagli, consulta la documentazione sulla Dashboard.

Modalità di distribuzione

Krawl supporta due modalità di distribuzione, controllate dall'impostazione mode in config.yaml o dalla variabile d'ambiente KRAWL_MODE.

StandaloneScalable
DatabaseSQLite (modalità WAL)PostgreSQL
Cachedict Python in memoriaRedis (TTL a più livelli)
Repliche1 (istanza singola)1+ (scalabilità orizzontale)
Dipendenze esterneNessunaPostgreSQL + Redis
Ideale perSviluppo, homelab, <500k richiesteProduzione, HA, >500k richieste

Standalone: ideale per ambienti di sviluppo o homelab con volumi di richieste ridotti. Nessuna configurazione aggiuntiva richiesta: basta eseguire Krawl e funziona.

  • Distribuzione a container singolo senza dipendenze esterne
  • Ridotto consumo di RAM e risorse

Scalable: progettata per ambienti di produzione o honeypot ad alto traffico. Il chart Helm utilizza questa modalità come predefinita.

  • Dashboard più veloce e reattiva grazie alla cache multi-livello di Redis
  • Ridotto I/O su disco grazie a Redis che agisce come cache hot-path davanti a PostgreSQL
  • La scalabilità orizzontale aumenta il numero di repliche di Krawl dietro un load balancer

Per la configurazione dettagliata, esempi Docker Compose, setup Kubernetes/Helm e istruzioni di migrazione passo-passo, consulta la documentazione sulle Modalità di distribuzione.

Banlist di Krawl

Krawl mantiene una banlist.txt regolarmente aggiornata con gli indirizzi IP degli attaccanti che hanno innescato le sue trappole honeypot. La banlist viene pubblicata settimanalmente ed è disponibile per il download, aiutando la comunità a bloccare preventivamente attori malintenzionati 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.

Condivisione delle banlist tra istanze

Le istanze di Krawl possono federare le proprie banlist: ciascuna può pubblicare la propria lista su un percorso non autenticato e importare le liste delle altre istanze (o qualsiasi lista di IP in testo semplice). Gli IP recuperati vengono integrati nelle decisioni di ban locali e mostrati nella dashboard.```yaml banlist:

Public, unauthenticated download path for this instance's banlist.

Supports the same ?categories= and ?fwtype= parameters as the main API.

Empty = disabled.

export_path: "/public_banlist.txt"

Upstream banlists to fetch and merge. Plain ".txt" lists work too.

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 all'indirizzo http://localhost:5000

Docker Compose

Crea un docker-compose.yaml con una delle due modalità di distribuzione.

Standalone: solo server Krawl con storage 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 usa **password predefinite** (`krawl`/`krawl`). **Cambiale 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 il deploy, 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/HEAD/docker/). Per lo **sviluppo** (build dal sorgente con hot-reload), usa i file compose in [`docker/dev/`](https://github.com/blessedrebus/krawl/blob/HEAD/docker/dev/).

Per maggiori dettagli su entrambe le modalità, vedi [Modalità di deployment](https://github.com/blessedrebus/krawl/blob/HEAD/docs/deployment-modes.md).

### Kubernetes
**Krawl è disponibile anche nativamente su Kubernetes**. L'installazione può essere effettuata [tramite manifest](https://github.com/blessedrebus/krawl/blob/HEAD/kubernetes/README.md) oppure [usando la Helm chart](https://github.com/blessedrebus/krawl/blob/HEAD/helm/README.md).

La Helm chart **predefinisce la modalità scalabile** con PostgreSQL e Redis inclusi:```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

Per entrambe le modalità sono forniti file values di esempio minimali:

Consulta Modalità di distribuzione e documentazione del Chart per istruzioni complete su configurazione e migrazione.

Uvicorn (Python)

Esegui Krawl direttamente con Python 3.13+ e uvicorn per lo sviluppo o i test locali:```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 all'indirizzo `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 i deployment Docker e per una personalizzazione rapida immediata.

### Configurazione tramite config.yaml
Puoi usare il file [config.yaml](https://github.com/blessedrebus/krawl/blob/HEAD/config.yaml) per configurazioni avanzate, come deployment con Docker Compose o Helm chart.

### 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` | Header 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 usati per la generazione dei link | `abcdefgh...` |
| `KRAWL_MAX_COUNTER` | Valore iniziale del contatore | `10` |
| `KRAWL_PROBABILITY_ERROR_CODES` | Probabilità di risposta con errore (0-100%) | `0` |
| `KRAWL_INFINITE_PAGES_FOR_MALICIOUS` | Serve 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, preriscaldamento della cache, Prometheus e livello di log.

| Variabile d'ambiente | Descrizione | Predefinito |
|----------------------|-------------|---------|
| `KRAWL_DASHBOARD_SECRET_PATH` | Percorso personalizzato della dashboard | Auto-generato |
| `KRAWL_DASHBOARD_PASSWORD` | Password per i pannelli protetti della dashboard | Auto-generata |
| `KRAWL_DASHBOARD_CACHE_WARMUP` | Pre-calcola i dati della dashboard ogni 5 minuti per caricamenti immediati delle pagine | `true` |
| `KRAWL_DASHBOARD_WARMUP_PAGES` | Numero di pagine da preriscaldare per pannello tabellare | `10` |
| `KRAWL_DASHBOARD_WARMUP_AGGREGATION` | Pre-calcola le aggregazioni complete top_paths/top_ua per servire senza query | `false` |
| `KRAWL_DASHBOARD_TOP_N_MIN_COUNT` | Conteggio minimo di accessi per i pannelli top paths/user agents (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 di accesso | `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 db | `true` |

</details>

<details>
<summary><b>Trappole: tarpit, pagine di deception 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 deception 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 | None |
| `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 i tempi di richiesta | `0.5` |
| `KRAWL_UNEVEN_REQUEST_TIMING_TIME_WINDOW_SECONDS` | Finestra temporale per l'analisi dei tempi di richiesta 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 virgola 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 virgola da recuperare e unire | Banlist della community Krawl |
| `KRAWL_BANLIST_REFRESH_INTERVAL` | Secondi tra un recupero e l'altro delle banlist upstream | `3600` |

</details>

<details>
<summary><b>Pagine di deception generate dall'IA</b> (10 variabili)</summary>

Vedi la [documentazione sulla generazione IA](https://github.com/blessedrebus/krawl/blob/HEAD/docs/ai_generation.md).

| Variabile d'ambiente | Descrizione | Predefinito |
|----------------------|-------------|---------|
| `KRAWL_AI_ENABLED` | Abilita le pagine di deception generate dall'IA | `false` |
| `KRAWL_AI_PROVIDER` | Provider IA (`"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 IA | `None` |
| `KRAWL_AI_MODEL` | Modello IA da usare per la generazione delle pagine | `"nvidia/nemotron-3-super-120b-a12b:free"` |
| `KRAWL_AI_TIMEOUT` | Timeout delle richieste in secondi per le chiamate API IA | `60` |
| `KRAWL_AI_MAX_DAILY_REQUESTS` | Numero massimo di pagine generate dall'IA al giorno (0 = illimitato) | `0` |
| `KRAWL_AI_PROMPT` | Template di prompt personalizzato per la generazione di pagine IA | Prompt predefinito |
| `KRAWL_AI_REASONING_ENABLED` | Abilita i token di reasoning (solo modelli di reasoning OpenRouter) | `false` |
| `KRAWL_AI_REASONING_EFFORT` | Sforzo di reasoning (`none`, `minimal`, `low`, `medium`, `high`, `xhigh`) | `"medium"` |

</details>

<details>
<summary><b>Modalità scalabile: PostgreSQL e Redis</b> (13 variabili)</summary>

Usata solo quando `KRAWL_MODE=scalable`. Vedi [Modalità di deployment](https://github.com/blessedrebus/krawl/blob/HEAD/docs/deployment-modes.md).

| Variabile d'ambiente | Descrizione | Predefinito |
|----------------------|-------------|---------|
| `KRAWL_MODE` | Modalità di deployment (`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 preriscaldamento 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 paginate della dashboard | `120` |

</details>


Per 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 una Docker run 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

## Usare Krawl per bannare IP malintenzionati
Krawl utilizza un sistema basato sulla reputazione per classificare gli indirizzi IP degli aggressori e offre due modalità per esportare elenchi di IP per l'integrazione con i 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 per 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 i parametri API completi, gli esempi e l'aggiunta di formati firewall personalizzati, consulta la documentazione dei Firewall Exporters.

Krawl può anche inviare gli IP bannati direttamente a una Cloudflare Account IP List per l'uso nelle regole WAF. La sincronizzazione viene eseguita come attività in background e aggiorna l'elenco mediante sostituzione completa a intervalli configurabili. Consulta la documentazione di Cloudflare Banlist Sync.

Reputazione IP

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.

ip reputation

L'analisi include:

  • Utilizzo di metodi HTTP rischiosi (ad es. rapporti POST, PUT, DELETE)
  • Violazioni di Robots.txt
  • Anomalie di temporizzazione delle richieste (pattern a raffica o irregolari)
  • Coerenza dello User-Agent
  • Rilevamento di URL di attacco (ad es. pattern di SQL injection, XSS)

Ogni segnale contribuisce a un modello di punteggio ponderato che assegna una categoria di reputazione:

  • attacker
  • bad_crawler
  • good_crawler
  • regular_user
  • unknown (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 automatiche come il ban degli IP o l'integrazione con i firewall.

Pagine di Deception Generate dall'IA

Krawl può generare automaticamente pagine di deception realistiche utilizzando modelli di IA dalle API di OpenRouter o OpenAI. Questa funzionalità crea al volo pagine honeypot uniche e plausibili per ingannare gli attaccanti senza la creazione manuale di pagine.

Caratteristiche Principali:

  • Generazione Dinamica: Crea pagine HTML uniche per qualsiasi percorso di richiesta
  • Cache Intelligente: Memorizza nella cache le pagine generate per evitare chiamate API ridondanti
  • Rate Limiting Giornaliero: Controlla i costi delle API con limiti di richiesta configurabili
  • Più Provider: Supporto per OpenRouter (opzioni gratuite) e OpenAI
  • Fallback Elegante: Ripiega sull'honeypot standard quando è disabilitato o il limite è stato raggiunto
  • Servizio dalla Cache: Le pagine generate in precedenza vengono servite anche quando l'IA è disabilitata

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 una configurazione e un utilizzo dettagliati, consulta la [documentazione AI Generation](https://github.com/blessedrebus/krawl/blob/HEAD/docs/ai_generation.md).

Puoi anche **contribuire con template di deception** aprendo una PR; consulta [Contribuire con template di deception tramite PR](https://github.com/blessedrebus/krawl/blob/HEAD/docs/deception_pages.md#contributing-deception-templates-via-pr).

## Esecuzione dietro un Reverse Proxy o CDN

**NGINX, Traefik e altri proxy come CloudFlare** richiedono l'inoltro degli header affinché Krawl possa vedere l'IP reale. Consulta la [documentazione Reverse Proxy](https://github.com/blessedrebus/krawl/blob/HEAD/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` (abilitato di default) e include una dashboard [Grafana](https://grafana.com/) pronta da importare in [`grafana-dashboard.json`](https://github.com/blessedrebus/krawl/blob/HEAD/grafana-dashboard.json).

Consulta la [documentazione Monitoring](https://github.com/blessedrebus/krawl/blob/HEAD/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

| Topic | Descrizione |
|-------|-------------|
| [AI Generation](https://github.com/blessedrebus/krawl/blob/HEAD/docs/ai_generation.md) | Configura pagine di deception generate dall'AI usando OpenRouter o OpenAI |
| [Pagine di Deception](https://github.com/blessedrebus/krawl/blob/HEAD/docs/deception_pages.md) | Gestisci, importa ed esporta pagine di deception; operazioni in blocco e filtri basati sulla data |
| [Modalità di Deploy](https://github.com/blessedrebus/krawl/blob/HEAD/docs/deployment-modes.md) | Modalità Standalone (SQLite) vs Scalable (PostgreSQL + Redis), configurazione e migrazione dei dati |
| [Honeypot](https://github.com/blessedrebus/krawl/blob/HEAD/docs/honeypot.md) | Panoramica completa delle pagine honeypot: login falsi, elenchi di directory, file di credenziali, trappole per SQLi/XSS/XXE/command injection e altro |
| [Dashboard](https://github.com/blessedrebus/krawl/blob/HEAD/docs/dashboard.md) | Accedi ed esplora la dashboard di monitoraggio in tempo reale |
| [API Dashboard](https://github.com/blessedrebus/krawl/blob/HEAD/docs/dashboard-api.md) | L'API JSON di Krawl: riferimento endpoint, autenticazione, documentazione OpenAPI interattiva e download degli allegati |
| [API Esterne](https://github.com/blessedrebus/krawl/blob/HEAD/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/HEAD/docs/reverse-proxy.md) | Come eseguire il deploy di Krawl dietro NGINX o usare sottodomini esca |
| [Backup del Database](https://github.com/blessedrebus/krawl/blob/HEAD/docs/backups.md) | Abilita e configura il processo automatico di dump del database |
| [Token Canary](https://github.com/blessedrebus/krawl/blob/HEAD/docs/canary-token.md) | Configura trigger di alert esterni tramite canarytokens.org |
| [Wordlist](https://github.com/blessedrebus/krawl/blob/HEAD/docs/wordlist.md) | Personalizza nomi utente, password e elenchi di directory falsi |
| [Architettura](https://github.com/blessedrebus/krawl/blob/HEAD/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/HEAD/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 la lista tramite sostituzione completa. |
| [Esportatori Firewall](https://github.com/blessedrebus/krawl/blob/HEAD/docs/firewall-exporters.md) | Esporta banlist di IP in formato raw, iptables o nftables tramite API REST |
| [Tarpit](https://github.com/blessedrebus/krawl/blob/HEAD/docs/tarpit.md) | Rallenta e avvelena i crawler AI con risposte ritardate e arricchite di rumore |
| [Metriche e Monitoraggio](https://github.com/blessedrebus/krawl/blob/HEAD/docs/monitoring.md) | Endpoint metriche Prometheus, riferimento delle metriche esposte, dashboard Grafana e scraping ServiceMonitor |

## Contributi

I contributi sono benvenuti! Per favore:
1. Fai il 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 nel rispetto delle leggi e dei regolamenti applicabili.

## Storico delle Star
<img src="https://star-history.dera.page/svg?repos=BlessedRebuS/Krawl&amp;type=Date" width="600" alt="Star History Chart" />
Leggi di più

Categorie

Sicurezza dei ContenitoriRaccolta InformazioniSicurezza WebSicurezza di ReteSicurezza CloudThreat IntelligenceRisposta agli IncidentiAnti-BotSicurezza dell'IA