[TODO] Lab - OpenCanary Honeypot: porte fake e detection lateral movement

Cosa fa
#

Avvia OpenCanary su Ubuntu con tre porte fake (SSH 2222, HTTP 8080, FTP 2121). Configura Wazuh per leggere i log JSON di OpenCanary e generare alert CRITICO per ogni connessione. Testa da Kali che ogni tentativo genera l'alert entro 30 secondi. Introduce anche la honeyfile (password-backup.txt) monitorata con inotifywait.

TL;DR
#

Ubuntu (192.168.64.3) → OpenCanary: SSH fake 2222, HTTP fake 8080, FTP fake 2121
                      → Wazuh: legge /var/log/opencanary.log (JSON) → alert level 12+
Kali (192.168.64.200) → si connette alle porte fake → viene rilevato

Honeypot = host/servizio fake che non dovrebbe ricevere traffico legittimo MAI
Honeynet  = rete di honeypot (simulare un'infrastruttura intera)
Honeyfile = file esca — trigger se qualcuno lo legge/copia

Obiettivo finale
#

Come sai che hai finito tutto:

ssh -p 2222 192.168.64.3 da Kali → alert Wazuh level >= 12 entro 30 sec
curl http://192.168.64.3:8080 da Kali → alert Wazuh entro 30 sec
ftp 192.168.64.3 2121 da Kali → alert Wazuh entro 30 sec
cat /data/confidential/password-backup.txt da qualsiasi shell su Ubuntu → alert inotifywait in /var/log/honeyfile.log

Fase 1 — Installazione OpenCanary
#

Task 1 — Installa OpenCanary via Docker

Crea ~/opencanary/opencanary.conf:

{
    "device.node_id": "mustache-opencanary",
    "logging.json": {
        "class": "PyLogger",
        "kwargs": {
            "formatters": {"plain": {"format": "%(message)s"}},
            "handlers": {
                "file": {
                    "class": "logging.FileHandler",
                    "filename": "/var/log/opencanary.log",
                    "formatter": "plain"
                }
            }
        }
    },
    "ssh.enabled": true,
    "ssh.port": 2222,
    "ssh.version": "SSH-2.0-OpenSSH_8.4p1 Debian-5",
    "http.enabled": true,
    "http.port": 8080,
    "http.banner": "Apache/2.4.51 (Ubuntu)",
    "ftp.enabled": true,
    "ftp.port": 2121,
    "ftp.banner": "220 FTP Server Ready"
}

Come sai che hai finito: docker run --rm opencanary/opencanary --help risponde

Task 2 — Avvia OpenCanary e verifica porte
- docker run -d --name opencanary -v ~/opencanary/opencanary.conf:/etc/opencanary/opencanary.conf:ro -v /var/log:/var/log -p 2222:2222 -p 8080:8080 -p 2121:2121 opencanary/opencanary
- Come sai che hai finito: ss -tlnp | grep -E "2222|8080|2121" mostra le tre porte in ascolto; /var/log/opencanary.log esiste

Fase 2 — Wazuh: ingestion log OpenCanary
#

Task 3 — Aggiungi il log OpenCanary a ossec.conf
- In /var/ossec/etc/ossec.conf aggiungi:
```
<localfile>
  <log_format>json</log_format>
  <location>/var/log/opencanary.log</location>
</localfile>
```
- Come sai che hai finito: systemctl restart wazuh-agent senza errori; Wazuh agent legge il file

Task 4 — Crea regola custom per alert CRITICO

In /var/ossec/etc/rules/local_rules.xml:

<group name="opencanary,honeypot,">
  <rule id="100200" level="12">
    <decoded_as>json</decoded_as>
    <field name="src_host">\.+</field>
    <description>HONEYPORT: Connessione a servizio fake rilevata da $(src_host) porta $(dst_port)</description>
    <group>honeypot,attack,</group>
  </rule>
</group>

Come sai che hai finito: /var/ossec/bin/ossec-logtest processa una riga di esempio JSON OpenCanary → mostra rule 100200 triggered

Fase 3 — Test honeypot da Kali
#

Task 5 — Connessione SSH fake
- Da Kali: ssh -p 2222 192.168.64.3 (premi Ctrl+C subito dopo)
- Su Ubuntu: tail -f /var/log/opencanary.log e tail -f /var/ossec/logs/alerts/alerts.json | grep -i honeyport
- Come sai che hai finito: alert Wazuh rule 100200 con src_host: 192.168.64.200 entro 30 sec
Task 6 — Connessione HTTP fake
- Da Kali: curl http://192.168.64.3:8080
- Come sai che hai finito: alert Wazuh per la connessione HTTP; OpenCanary risponde con la pagina Apache fake
Task 7 — Connessione FTP fake
- Da Kali: ftp 192.168.64.3 2121 (digita quit subito)
- Come sai che hai finito: alert Wazuh per connessione FTP; il banner mostra il messaggio fake

Fase 4 — Honeyfile con inotifywait
#

Task 8 — Crea honeyfile e monitor
- Su Ubuntu: echo "DB_PASSWORD=Mustache2024! DB_HOST=192.168.64.3" > /data/confidential/password-backup.txt
- Configura inotifywait in background:
```
inotifywait -m /data/confidential/password-backup.txt -e access,open 2>/dev/null | while read; do
  echo "$(date) - HONEYFILE ACCESSED: password-backup.txt" >> /var/log/honeyfile.log
done &
```
- Come sai che hai finito: ls -la /data/confidential/password-backup.txt esiste; il processo inotifywait è in background
Task 9 — Testa il honeyfile
- Su Ubuntu: cat /data/confidential/password-backup.txt
- Come sai che hai finito: /var/log/honeyfile.log contiene una riga con timestamp e "HONEYFILE ACCESSED"

Domande di verifica Security+
#

Qual è la differenza tra un honeypot e una honeynet? In quale scenario usi una honeynet intera?
OpenCanary risponde a ssh -p 2222 con un banner fake. L'attaccante sa che è un honeypot? Perché è comunque utile?
Una honeyfile non rileva chi la copia sulla rete — rileva solo chi la legge localmente. Cosa aggiunge il Canary Token a questo scenario? (hint: vedi lab-honeytoken-canary)
Nessun utente legittimo di Mustache Corp dovrebbe mai connettersi alle porte 2222, 8080, 2121. Questo è il principio fondamentale del honeypot. Come si chiama questo tipo di detection? (hint: non è signature-based)
inotifywait monitora accessi al file system. Perché questo complementa Wazuh FIM invece di sostituirlo?

Collegato a
#

[[[TODO] lab-honeytoken-canary|lab-honeytoken-canary]] — honeytoken su file PDF: detection fuori dal perimetro
[[[DONE] lab-suricata-ips-inline|lab-suricata-ips-inline]] — IPS blocca il traffico; honeypot lo lascia passare per studiarlo
cap-04-securing-your-network — honeypot, honeynet, honeyfile, honeytoken, deception technology

Cosa fa#

TL;DR#

Obiettivo finale#

Fase 1 — Installazione OpenCanary#

Fase 2 — Wazuh: ingestion log OpenCanary#

Fase 3 — Test honeypot da Kali#

Fase 4 — Honeyfile con inotifywait#

Domande di verifica Security+#

Collegato a#

Related