Semplice honeypot in Python: guida pratica per testare il traffico nel laboratorio
Promemoria importante
Uso consentito e sicurezza
Esegui questo honeypot solo in un laboratorio isolato (Host-Only / Internal Network) e con autorizzazione scritta. Un honeypot cattura traffico potenzialmente malevolo: usalo esclusivamente a scopi didattici e difensivi. Non esporre il servizio su Internet pubblico.
Che cosa vedrai in questa pagina
Contenuti
Spiego cosa è un honeypot HTTP leggero, come funziona il piccolo server Python proposto, come eseguirlo nel laboratorio (senza Docker o con Docker), come leggere i log e alcune estensioni utili per analisi e integrazione con sistemi di logging.
Perché creare un honeypot semplice
Obiettivi
- Raccogliere informazioni su scansioni e probe (IP, URI, user-agent).
- Testare pipeline di logging e alerting (file, syslog, ELK).
- Fornire un target sicuro e isolato per esercitazioni di rilevamento.
Strumenti necessari
Prerequisiti software
- Python 3.8+ installato sulla macchina che esegue il honeypot.
- Opzionale: Docker (per containerizzare il honeypot).
- Un editor di testo (es. Visual Studio Code, nano).
Codice: honeypot HTTP minimale in Python (senza eseguire payload)
Descrizione del comportamento
Il server registra in un file log le richieste in arrivo (timestamp UTC, IP, metodo, path, query, header e body). Non esegue comandi ricevuti dal client e risponde sempre con una pagina finta "Service unavailable" per sembrare un servizio reale ma sicuro.
File: honeypot.py
# honeypot.py
from flask import Flask, request, Response
import logging
from datetime import datetime
import json
import os
app = Flask(**name**)
LOGFILE = os.environ.get("HONEYPOT\_LOG", "honeypot.log")
logging.basicConfig(level=logging.INFO, filename=LOGFILE, format="%(message)s")
def log\_request(req):
entry = {
"time": datetime.utcnow().isoformat() + "Z",
"ip": req.remote\_addr,
"method": req.method,
"path": req.path,
"query": req.query\_string.decode(errors="ignore"),
"headers": dict(req.headers),
"body": req.get\_data(as\_text=True)
}
\# registra come JSON per facilitare parsing successivo
logging.info(json.dumps(entry))
@app.route("/", defaults={"path": ""}, methods=\["GET","POST","PUT","DELETE","OPTIONS","HEAD","PATCH"])
@app.route("/\", methods=\["GET","POST","PUT","DELETE","OPTIONS","HEAD","PATCH"])
def catch\_all(path):
log\_request(request)
\# risposta finta, non eseguire nulla ricevuto
body = "\\\Service temporarily unavailable\
\\"
return Response(body, status=200, mimetype="text/html")
if **name** == "**main**":
\# ascolta su 0.0.0.0:8080 (adatta la porta al tuo laboratorio)
app.run(host="0.0.0.0", port=8080) Esecuzione locale (senza Docker)
Passi rapidi
- Salva il file precedente come
honeypot.py. - Installa dipendenze e avvia:
python3 -m venv venv
source venv/bin/activate # su Windows: venv\Scripts\activate
pip install --upgrade pip
pip install flask
python honeypot.py
Il server ascolterà sulla porta 8080. Dal tuo host/VM di attacco puoi testare con curl o un browser verso http\://\.
Esecuzione in Docker (consigliato per isolamento)
Dockerfile
# Dockerfile
FROM python:3.11-slim
WORKDIR /app
COPY honeypot.py /app/
RUN pip install --no-cache-dir flask
VOLUME \["/data"]
EXPOSE 8080
CMD \["python", "honeypot.py"] Build e run del container
# dalla cartella con Dockerfile e honeypot.py
docker build -t simple-honeypot\:latest .
# crea una rete Docker isolata per il lab (opzionale)
docker network create lab-net
# avvia il container con volume per i log e rete isolata
docker run -d --name honeypot --network lab-net -p 127.0.0.1:8080:8080 -v "\$(pwd)/data":/app simple-honeypot\:latest Nota: la porta è esposta solo su localhost (127.0.0.1) per evitare esposizione pubblica; se usi una rete Docker interna (lab-net), puoi collegare anche la VM attaccante a quella rete.
Come leggere i log
Formati e comandi
I log vengono salvati in JSON riga per riga in honeypot.log (o nella cartella data/ montata nel container). Esempi di comandi utili:
```
# in locale
tail -f honeypot.log
# se i log sono montati in ./data
tail -f data/honeypot.log
# visualizzare le ultime 5 entries formattate (jq richiesto)
tail -n 20 data/honeypot.log | jq -r '.' Testare il honeypot dal nodo attaccante
Esempi di probe
- Scansione semplice con nmap:
nmap -p 8080 <IP_honeypot> - Richiesta HTTP con payload:
curl -X POST -d "test=1" http://<IP_honeypot>:8080/login - Simulare scanner web:
nikto -host http://<IP_honeypot>:8080
Regole base di detection
Cosa cercare nei log
- Molte richieste dallo stesso IP in un intervallo breve (scan rapido).
- URI sospette come
/admin,/phpmyadmin,/wp-login.php. - User-agent riconducibili a scanner automatizzati o assenti.
- Payload con pattern tipici di exploit (es.
../,union select, stringhe di injection).
Estensioni suggerite
Migliorie rapide
- Simulare pagine come
/admino/logine registrare accessi specifici. - Inviare i log via Filebeat a un'istanza Elasticsearch per dashboard Kibana.
- Aggiungere alert via script (email/Slack) quando un IP supera una soglia di richieste.
- Per interazione avanzata valutare Cowrie (honeypot SSH) o altre soluzioni di medium interaction.
Rischi e buone pratiche
Precauzioni
- Non connettere il honeypot a reti di produzione o a Internet pubblico.
- Non eseguire i payload ricevuti dal client: il codice registrerà solo i dati e non li esegue.
- Proteggi i file di log; possono contenere dati personali o stringhe sensibili.
- Usa immagini Docker ufficiali come base e verifica sempre le sorgenti.
Risorse e approfondimenti
Link utili
- Flask: flask.palletsprojects.com
- Docker: docker.com
- Cowrie (honeypot SSH avanzato): github.com/cowrie/cowrie
- Elastic Stack (ELK): elastic.co/elastic-stack
Articolo generato da ChatGPT.
