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

Reactor.

Explotación de una versión vulnerable de React (CVE-2025-55182 - React2Shell), ejecución remota de código, estabilización con servidor C2, acceso a base de datos SQLite y escalada de privilegios mediante depurador Node.js corriendo como root.

PlataformaHackTheBox
DificultadFÁCIL
Vector inicialRCE en React (React2Shell) → C2
EscaladaDepurador de Node.js expuesto → root
CVEsCVE-2025-55182
Autorkeltich · KeltichCibSec
Nmap → RCE React2Shell → Servidor C2 → SQLite → hash → SSH (user) → Node.js debugger → root
// 01

Reconocimiento

Como siempre, un ping ICMP para comprobar que hay conexión con la máquina:

ping ICMP a la máquina
Comprobación de conectividad.

El TTL de la respuesta vuelve en 63. Como Linux parte de un TTL de 64 y aquí vemos 63, hay un salto de router por el camino (64 − 1): es una pista de que la máquina es Linux.

Con eso claro, lanzamos el escaneo TCP con Nmap para descubrir puertos:

Escaneo Nmap de puertos
Nmap — puertos abiertos.

Aparecen dos puertos: el 22 y el 3000. Con los puertos localizados, un escaneo más a fondo (-sCV) para ver qué corre en ellos:

Nmap -sCV de servicios
Nmap — servicios y versiones.

El 22 es SSH. El 3000 aparece etiquetado por Nmap como «ppp», pero eso es solo el nombre que Nmap asigna por defecto a ese número de puerto según su fichero de servicios — no es PPP de verdad. Si lo visitamos por HTTP vemos que en realidad es una aplicación web:

Aplicación web en el puerto 3000
La web servida en el puerto 3000.
// 02

Explotación

Empezamos con fuzzing para buscar directorios en la web, pero lo que aparece no da mucho juego. Cambiamos de enfoque: buscar una vulnerabilidad conocida en la propia tecnología de la página.

Resultado del fuzzing de directorios
El fuzzing no revela nada aprovechable de entrada.

Con clic derecho → Inspeccionar abrimos las herramientas de desarrollador del navegador y revisamos el HTML y el código de la página:

Herramientas de desarrollador abiertas
DevTools sobre la página.
HTML de la página
El HTML servido.

En la pestaña Debugger (o Sources) están los archivos JavaScript que dan lógica a la página:

Archivos JavaScript en el Debugger
Los ficheros JS de la aplicación.
Código desplegado en el Debugger
El código de la página desplegado.

Para averiguar la versión de React, abrimos el primer archivo JS y buscamos con Ctrl+F la palabra version:

Búsqueda de la versión de React en el JS
Localizamos la versión en el bundle de JavaScript.

Es la 19.0.0. Esa versión arrastra una vulnerabilidad interesante:

React2Shell — CVE-2025-55182 Es una ejecución remota de código (RCE) que afecta a React en entornos de servidor (Next.js, SSR…). Una cadena de exploits que permite ejecutar comandos arbitrarios en el servidor donde corre la aplicación React/Next.js, en muchos casos sin autenticación.

Explotándola conseguimos una shell en el servidor donde se alojan los recursos de la página:

Shell obtenida en el servidor mediante React2Shell
Primer acceso al servidor vía React2Shell.

La shell del RCE es limitada —recorta la salida y estorba para trabajar—, así que lo primero es estabilizar el acceso. Aquí se optó por un servidor de mando y control (C2) propio, dejando en la víctima un agente que conecta de vuelta a nuestra máquina:

Configuración del servidor C2
Preparación del C2 apuntando a nuestra IP.
Descarga del agente en la víctima
El agente se descarga en la máquina víctima.
Ejecución del agente
Y se ejecuta (con el C2 ya iniciado).
Agente conectado al C2
El agente aparece conectado en el C2.

Desde la consola del C2, !list muestra los agentes conectados y !intrude <id> abre una consola sobre la víctima. Como esa consola sigue siendo interactiva y limitada, lanzamos desde ella una reverse shell de revshells.com contra un netcat a la escucha. Primero el listener:

netcat a la escucha
netcat esperando la reverse shell.

Y la reverse shell insertada desde la consola del C2:

Reverse shell lanzada desde el C2
Recibimos una shell más manejable.

Rebuscando por el sistema, la contraseña del usuario engineer está en una base de datos SQLite en /home/node, llamada reactor.db. Un cat directo no se ve bien, pero ensanchando la terminal aparece un hash que, por las relaciones de la tabla, corresponde a engineer:

Hash de engineer en reactor.db
El hash de engineer dentro de reactor.db.

Toca identificar y crackear el hash con hashcat. Primero lo identificamos con hashid:

Identificación del hash con hashid
hashid apunta a MD5.

hashcat necesita el modo correcto. Consultamos la referencia con hashcat -h | less (se sale con q). El modo de MD5 es el 0:

Modo 0 (MD5) en la ayuda de hashcat
MD5 → -m 0.

Y el tipo de ataque: el 0 es straight, un ataque directo por diccionario:

Modo de ataque straight (0) en hashcat
Ataque directo → -a 0.

Con esos dos datos montamos el comando:

Comando de hashcat construido
hashcat -m 0 -a 0 hash.txt rockyou.txt.

Y lo crackeamos, obteniendo la contraseña en claro:

Contraseña de engineer recuperada
Contraseña de engineer recuperada.

Con ella entramos por SSH como engineer:

Acceso SSH como engineer
Sesión SSH como engineer.
USER FLAG
deb898b0e194ba07fc5665f1a0486005
// 03

Escalada de privilegios

Para enumerar vías de escalada usamos LinPEAS. Como no se puede descargar directamente en la víctima, lo transferimos por SSH con scp:

scp linpeas.sh engineer@<IP>:/tmp/
Transferencia de LinPEAS con scp
LinPEAS copiado a la víctima.

Le damos permisos de ejecución y lo lanzamos. LinPEAS resalta por colores los vectores según su importancia:

Salida de LinPEAS con posibles vectores
LinPEAS marca los puntos de interés.
La vulnerabilidad En la máquina corre un Node.js Inspector (el depurador de Node) en el puerto 9229, lanzado por root con --inspect y sin pedir contraseña a quien se conecte desde la propia máquina. Un depurador con esos permisos es ejecución de código como root servida en bandeja.

Cómo se descubre. Con ss -lntp se ve que el 9229 escucha en local (127.0.0.1:9229), y con ps aux | grep node se confirma que ese proceso de Node —el del --inspect— pertenece a root.

ss -lntp ps aux | grep node

La explotación, paso a paso. Nos conectamos al depurador:

node inspect 127.0.0.1:9229

Y, desde su consola, inyectamos un comando que se ejecuta en el sistema. Le ponemos el bit SUID a /bin/bash:

exec("process.mainModule.require('child_process').execSync('chmod +s /bin/bash')")

Esto usa el módulo interno child_process de Node para lanzar chmod +s /bin/bash. Como el depurador corre como root, el comando se ejecuta como root y marca /bin/bash como SUID: a partir de ahí, cualquiera puede lanzar esa bash con los privilegios de su dueño (root).

Salimos del depurador con Ctrl+C y ejecutamos:

bash -p

El -p (preserve) hace que la shell conserve los privilegios heredados del SUID: nos convertimos en root al instante.

Shell de root obtenida
Ya somos root.

Y con ello, la flag de root:

ROOT FLAG
fa0b25bee2b2e422802eb9116da75af5
root@keltich:~/HackTheBox/Reactor
root@keltich:~$

COMANDOS

← Volver a Artículos