Update README

Introduccion-hacking-hack4u/README.md

@@ -20,5 +20,15 @@ Recuerda,
 | [4. Enumeración de servicios comunes y gestores de contenido](./tema_4_enumeracion/README.md) |
 | [5. Conceptos básicos de enumeración y explotación](./tema_5_conceptos/README.md) |
 | [6. OWASP TOP 10 y vulnerabilidades web](./tema_6_owasp/README.md) |
+| [7. Técnicas de escalada de privilegios](./tema_7_escalada/README.md) |
+| [8. Buffer Overflow](./tema_8_buffer_overflow/README.md) |
+| [Material Adicional](./tema_9_material_adic/README.md) |
 
 
+
+Máquinas para prácticas:
+- Máquina IMF 1: https://www.vulnhub.com/entry/imf-1,162/
+- Máquina Casino Royale 1: https://www.vulnhub.com/entry/casino-royale-1,287/
+- Máquina Symfonos 6.1: https://www.vulnhub.com/entry/symfonos-61,458/
+- Máquina Presidential 1: https://www.vulnhub.com/entry/presidential-1,500/
+- Máquina Infovore 1: https://www.vulnhub.com/entry/infovore-1,496/

Introduccion-hacking-hack4u/tema_7_escalada/README.md

@@ -0,0 +1,246 @@
+# TEMA 7 - Técnicas de escalada de privilegios
+
+
+Índice:
+- [TEMA 7 - Técnicas de escalada de privilegios](#tema-7---técnicas-de-escalada-de-privilegios)
+  - [7.1. Abusando de privilegios a nivel de Sudoers](#71-abusando-de-privilegios-a-nivel-de-sudoers)
+  - [7.2. Abusando de privilegios SUID](#72-abusando-de-privilegios-suid)
+  - [7.3. Detección y explotación de tareas Cron](#73-detección-y-explotación-de-tareas-cron)
+  - [7.4. PATH Hijacking](#74-path-hijacking)
+  - [7.5. Python Library Hijacking](#75-python-library-hijacking)
+  - [7.6. Abuso de permisos incorrectamente implementados](#76-abuso-de-permisos-incorrectamente-implementados)
+  - [7.7. Detección y explotación de Capabilities](#77-detección-y-explotación-de-capabilities)
+  - [7.8. Explotación del Kernel](#78-explotación-del-kernel)
+  - [7.9. Abuso de grupos de usuario especiales](#79-abuso-de-grupos-de-usuario-especiales)
+  - [7.10. Abuso de servicios internos del sistema](#710-abuso-de-servicios-internos-del-sistema)
+  - [7.11. Abuso de binarios especificos](#711-abuso-de-binarios-especificos)
+  - [7.12. Secuestro de la biblioteca de objetos compartidos enlazadas dinámicamente](#712-secuestro-de-la-biblioteca-de-objetos-compartidos-enlazadas-dinámicamente)
+  - [7.13. Docker Breakout](#713-docker-breakout)
+
+
+
+## 7.1. Abusando de privilegios a nivel de Sudoers
+
+El archivo /etc/sudoers es un archivo de configuración en sistemas Linux que se utiliza para controlar el acceso de los usuarios a las diferentes acciones que pueden realizar en el sistema. Este archivo contiene una lista de usuarios y grupos de usuarios que tienen permisos para realizar tareas de administración en el sistema.
+
+El comando “sudo” permite a los usuarios ejecutar comandos como superusuario o como otro usuario con privilegios especiales. El archivo sudoers especifica qué usuarios pueden ejecutar qué comandos con sudo y con qué privilegios.
+
+Abusar de los privilegios a nivel de sudoers es una técnica utilizada por los atacantes para elevar su nivel de acceso en un sistema comprometido. Si un atacante es capaz de obtener acceso a una cuenta con permisos de sudo en el archivo sudoers, puede ejecutar comandos con privilegios especiales y realizar acciones maliciosas en el sistema.
+
+El comando “sudo -l” es utilizado para listar los permisos de sudo de un usuario en particular. Al ejecutar este comando, se muestra una lista de los comandos que el usuario tiene permiso para ejecutar y bajo qué condiciones.
+
+Para prevenir el abuso de privilegios a nivel de sudoers, se recomienda mantener los permisos adecuados en el archivo sudoers y limitar el número de usuarios con permisos de sudo. Además, es importante monitorear regularmente el archivo sudoers y buscar cambios inesperados o sospechosos en su contenido.
+
+A continuación, se os comparte el recurso GTFOBINS el cual utilizamos en esta clase para detectar comandos que potencialmente puedan ser explotados para elevar nuestro privilegio de usuario:
+
+- GTFOBins: https://gtfobins.github.io/ 
+
+
+## 7.2. Abusando de privilegios SUID
+
+Un privilegio SUID (Set User ID) es un permiso especial que se puede establecer en un archivo binario en sistemas Unix/Linux. Este permiso le da al usuario que ejecuta el archivo los mismos privilegios que el propietario del archivo.
+
+Por ejemplo, si un archivo binario tiene establecido el permiso SUID y es propiedad del usuario root, cualquier usuario que lo ejecute adquirirá temporalmente los mismos privilegios que el usuario root, lo que le permitirá realizar acciones que normalmente no podría hacer como un usuario normal.
+
+El abuso de privilegios SUID es una técnica utilizada por los atacantes para elevar su nivel de acceso en un sistema comprometido. Si un atacante es capaz de obtener acceso a un archivo binario con permisos SUID, puede ejecutar comandos con privilegios especiales y realizar acciones maliciosas en el sistema.
+
+Para prevenir el abuso de privilegios SUID, se recomienda limitar el número de archivos con permisos SUID y asegurarse de que solo se otorguen a archivos que requieran este permiso para funcionar correctamente. Además, es importante monitorear regularmente el sistema para detectar cambios inesperados en los permisos de los archivos y para buscar posibles brechas de seguridad.
+
+Una vez más, se os comparte el mismo recurso que en la clase anterior, dado que esta página también contempla los binarios con permiso SUID que potencialmente pueden ser explotados:
+
+- GTFOBins: https://gtfobins.github.io
+
+
+
+## 7.3. Detección y explotación de tareas Cron
+
+Una tarea cron es una tarea programada en sistemas Unix/Linux que se ejecuta en un momento determinado o en intervalos regulares de tiempo. Estas tareas se definen en un archivo crontab que especifica qué comandos deben ejecutarse y cuándo deben ejecutarse.
+
+La detección y explotación de tareas cron es una técnica utilizada por los atacantes para elevar su nivel de acceso en un sistema comprometido. Por ejemplo, si un atacante detecta que un archivo está siendo ejecutado por el usuario “root” a través de una tarea cron que se ejecuta a intervalos regulares de tiempo, y se da cuenta de que los permisos definidos en el archivo están mal configurados, podría manipular el contenido del mismo para incluir instrucciones maliciosas las cuales serían ejecutadas de forma privilegiada como el usuario ‘root’, dado que corresponde al usuario que está ejecutando dicho archivo.
+
+Ahora bien, para detectar tareas cron, los atacantes pueden utilizar herramientas como Pspy. Pspy es una herramienta de línea de comandos que monitorea las tareas que se ejecutan en segundo plano en un sistema Unix/Linux y muestra las nuevas tareas que se inician.
+
+Con el objetivo de reducir las posibilidades de que un atacante lograra explotar las tareas cron en un sistema, se recomienda llevar a cabo alguno de los siguientes puntos:
+
+- Limitar el número de tareas cron: es importante limitar el número de tareas cron que se ejecutan en el sistema y asegurarse de que solo se otorgan permisos a tareas que requieren permisos especiales para funcionar correctamente. Esto disminuye la superficie de ataque y reduce las posibilidades de que un atacante pueda encontrar una tarea cron vulnerable.
+- Verificar los permisos de las tareas cron: es importante revisar los permisos de las tareas cron para asegurarse de que solo se otorgan permisos a usuarios y grupos autorizados. Además, se recomienda evitar otorgar permisos de superusuario a las tareas cron, a menos que sea estrictamente necesario.
+- Supervisar regularmente el sistema: es importante monitorear regularmente el sistema para detectar cambios inesperados en las tareas cron y para buscar posibles brechas de seguridad. Además, se recomienda utilizar herramientas de monitoreo de seguridad para detectar actividades sospechosas en el sistema.
+- Configurar los registros de la tarea cron: se recomienda habilitar la opción de registro para las tareas cron, para poder identificar cualquier actividad sospechosa en las tareas definidas y para poder llevar un registro de las actividades realizadas por cada una de estas.
+
+A continuación, se comparte el enlace al proyecto de Github correspondiente a la herramienta Pspy:
+
+- Herramienta Pspy: https://github.com/DominicBreuker/pspy
+
+
+## 7.4. PATH Hijacking
+
+PATH Hijacking es una técnica utilizada por los atacantes para secuestrar comandos de un sistema Unix/Linux mediante la manipulación del PATH. El PATH es una variable de entorno que define las rutas de búsqueda para los archivos ejecutables en el sistema.
+
+En algunos binarios compilados, algunos de los comandos definidos internamente pueden ser indicados con una ruta relativa en lugar de una ruta absoluta. Esto significa que el binario busca los archivos ejecutables en las rutas especificadas en el PATH, en lugar de utilizar la ruta absoluta del archivo ejecutable.
+
+Si un atacante es capaz de alterar el PATH y crear un nuevo archivo con el mismo nombre de uno de los comandos definidos internamente en el binario, puede lograr que el binario ejecute la versión maliciosa del comando en lugar de la versión legítima.
+
+Por ejemplo, si un binario compilado utiliza el comando “ls” sin su ruta absoluta en su código y el atacante crea un archivo malicioso llamado “ls” en una de las rutas especificadas en el PATH, el binario ejecutará el archivo malicioso en lugar del comando legítimo “ls” cuando sea llamado.
+
+Para prevenir el PATH Hijacking, se recomienda utilizar rutas absolutas en lugar de rutas relativas en los comandos definidos internamente en los binarios compilados. Además, es importante asegurarse de que las rutas en el PATH sean controladas y limitadas a las rutas necesarias para el sistema. También se recomienda utilizar la opción de permisos de ejecución para los archivos ejecutables solo para los usuarios y grupos autorizados.
+
+
+## 7.5. Python Library Hijacking
+
+Cuando hablamos de ‘Python Library Hijacking‘, a lo que nos referimos es a una técnica de ataque que aprovecha la forma en la que Python busca y carga bibliotecas para inyectar código malicioso en un script. El ataque se produce cuando un atacante crea o modifica una biblioteca en una ruta accesible por el script de Python, de tal manera que cuando el script la importa, se carga la versión maliciosa en lugar de la legítima.
+
+La forma en que el ataque se lleva a cabo es la siguiente: el atacante busca una biblioteca utilizada por el script y la reemplaza por su propia versión maliciosa. Esta biblioteca puede ser una biblioteca estándar de Python o una biblioteca externa descargada e instalada por el usuario. El atacante coloca su versión maliciosa de la biblioteca en una ruta accesible antes de que la biblioteca legítima sea encontrada.
+
+En general, Python comienza buscando estas bibliotecas en el directorio actual de trabajo y luego en las rutas definidas en la variable sys.path. Si el atacante tiene acceso de escritura en alguna de las rutas definidas en sys.path, puede colocar allí su propia versión maliciosa de la biblioteca y hacer que el script la cargue en lugar de la legítima.
+
+Además, el atacante también puede crear su propia biblioteca en el directorio actual de trabajo, ya que Python comienza la búsqueda en este directorio por defecto. Si durante la carga de estas librerías desde el script legítimo, el atacante logra secuestrarlas, entonces conseguirá una ejecución alternativa del programa.
+
+
+## 7.6. Abuso de permisos incorrectamente implementados
+
+En sistemas Linux, los archivos y directorios tienen permisos que se utilizan para controlar el acceso a ellos. Los permisos se dividen en tres categorías: propietario, grupo y otros. Cada categoría puede tener permisos de lectura, escritura y ejecución. Los permisos de un archivo pueden ser modificados por el propietario o por el superusuario del sistema.
+
+El abuso de permisos incorrectamente implementados ocurre cuando los permisos de un archivo crítico son configurados incorrectamente, permitiendo a un usuario no autorizado acceder o modificar el archivo. Esto puede permitir a un atacante leer información confidencial, modificar archivos importantes, ejecutar comandos maliciosos o incluso obtener acceso de superusuario al sistema.
+
+De esta forma, un atacante experimentado podría aprovecharse de esta falla para elevar sus privilegios en el mejor de los casos. Una de las herramientas encargadas de aplicar este reconocimiento en el sistema es ‘lse‘. Linux Smart Enumeration (LSE) es una herramienta de enumeración de seguridad para sistemas operativos basados en Linux, diseñada para ayudar a los administradores de sistemas y auditores de seguridad a identificar y evaluar vulnerabilidades y debilidades en la configuración del sistema.
+
+LSE está diseñado para ser fácil de usar y proporciona una salida clara y legible para facilitar la identificación de problemas de seguridad. La herramienta utiliza comandos de Linux estándar y se ejecuta en la línea de comandos, lo que significa que no se requiere software adicional. Además, enumera una amplia gama de información del sistema, incluyendo usuarios, grupos, servicios, puertos abiertos, tareas programadas, permisos de archivos, variables de entorno y configuraciones del firewall, entre otros.
+
+A continuación, se os proporciona el enlace directo al proyecto de Github correspondiente a esta herramienta:
+
+- Linux Smart Enumeration: https://github.com/diego-treitos/linux-smart-enumeration
+
+
+## 7.7. Detección y explotación de Capabilities
+
+En sistemas Linux, las capabilities son una funcionalidad de seguridad que permite a los usuarios realizar acciones que normalmente requieren privilegios de superusuario (root), sin tener que concederles acceso completo de superusuario. Esto se hace para mejorar la seguridad, ya que un proceso que solo necesita ciertos privilegios puede obtenerlos sin tener que ejecutarse como root.
+
+Las capabilities se dividen en 3 tipos:
+
+- Permisos efectivos (effective capabilities): son los permisos que se aplican directamente al proceso que los posee. Estos permisos determinan las acciones que el proceso puede realizar. Por ejemplo, la capability “CAP_NET_ADMIN” permite al proceso modificar la configuración de red.
+- Permisos heredados (inheritable capabilities): son los permisos que se heredan por los procesos hijos que son creados. Estos permisos pueden ser adicionales a los permisos efectivos que ya posee el proceso padre. Por ejemplo, si un proceso padre tiene la capability “CAP_NET_ADMIN” y esta capability se configura como heredable, entonces los procesos hijos también tendrán la capability “CAP_NET_ADMIN“.
+- Permisos permitidos (permitted capabilities): son los permisos que un proceso tiene permitidos. Esto incluye tanto permisos efectivos como heredados. Un proceso solo puede ejecutar acciones para las que tiene permisos permitidos. Por ejemplo, si un proceso tiene la capability “CAP_NET_ADMIN” y la capability “CAP_SETUID” configurada como permitida, entonces el proceso puede modificar la configuración de red y cambiar su UID (User ID).
+
+Ahora bien, algunas capabilities pueden suponer un riesgo desde el punto de vista de la seguridad si se les asignan a determinados binarios. Por ejemplo, la capability cap_setuid permite a un proceso establecer el UID (User ID) de un proceso a otro valor diferente al suyo, lo que puede permitir que un usuario malintencionado ejecute código malicioso con privilegios elevados.
+
+Para listar las capabilities de un archivo binario en Linux, puedes usar el comando getcap. Este comando muestra las capabilities efectivas, heredables y permitidas del archivo. Por ejemplo, para ver las capabilities del archivo binario /usr/bin/ping, puedes ejecutar el siguiente comando en la terminal:
+
+```
+getcap /usr/bin/ping
+```
+
+La salida del comando mostrará las capabilities asignadas al archivo:
+```
+/usr/bin/ping = cap_net_admin,cap_net_raw+ep
+```
+
+En este caso, el binario ping tiene dos capabilities asignadas: cap_net_admin y cap_net_raw+ep. La última capability (cap_net_raw+ep) indica que el archivo tiene el bit de ejecución elevado (ep) y la capability cap_net_raw asignada.
+
+Para asignar una capability a un archivo binario, puedes utilizar el comando setcap. Este comando establece las capabilities efectivas, heredables y permitidas para el archivo especificado.
+
+Por ejemplo, para otorgar la capability cap_net_admin al archivo binario /usr/bin/my_program, puedes ejecutar el siguiente comando en la terminal:
+
+```
+sudo setcap cap_net_admin+ep /usr/bin/my_program
+```
+
+En este caso, el comando otorga la capability cap_net_admin al archivo /usr/bin/my_program, y también establece el bit de ejecución elevado (ep). Ahora, el archivo my_program tendrá permisos para administrar la configuración de red.
+
+El bit de ejecución elevado (en inglés, elevated execution bit o “ep“) es un atributo especial que se puede establecer en un archivo binario en Linux. Este atributo se utiliza en conjunción con las capabilities para permitir que un archivo se ejecute con permisos especiales, incluso si el usuario que lo ejecuta no tiene privilegios de superusuario.
+
+Cuando un archivo binario tiene el bit de ejecución elevado establecido, se puede ejecutar con las capabilities efectivas asignadas al archivo, en lugar de las capabilities del usuario que lo ejecuta. Esto significa que el archivo puede realizar acciones que normalmente solo están permitidas a los usuarios con privilegios elevados.
+
+Es importante señalar que los permisos permitidos pueden ser limitados aún más mediante el uso de un mecanismo de control de acceso obligatorio (MAC, Mandatory Access Control), como SELinux o AppArmor, que restringen las acciones que los procesos pueden realizar en función de la política de seguridad del sistema.
+
+
+## 7.8. Explotación del Kernel
+
+El kernel es la parte central del sistema operativo Linux, que se encarga de administrar los recursos del sistema, como la memoria, los procesos, los archivos y los dispositivos. Debido a su papel crítico en el sistema, cualquier vulnerabilidad en el kernel puede tener graves consecuencias para la seguridad del sistema.
+
+En versiones antiguas del kernel de Linux, se han descubierto vulnerabilidades que pueden ser explotadas para permitir a los atacantes obtener acceso de superusuario (root) en el sistema.
+
+La elevación de privilegios se refiere a la técnica utilizada por los atacantes para obtener permisos elevados en el sistema, como superusuario (root), cuando solo tienen permisos limitados. Por ejemplo, un usuario con permisos limitados en el sistema podría utilizar una vulnerabilidad en el kernel para obtener acceso de superusuario y, posteriormente, comprometer el sistema.
+
+Las vulnerabilidades del kernel pueden ser explotadas de varias maneras. Por ejemplo, un atacante podría aprovechar una vulnerabilidad en un controlador de dispositivo para obtener acceso al kernel y realizar operaciones maliciosas. Otra forma común en que se explotan las vulnerabilidades del kernel es mediante el uso de técnicas de desbordamiento de búfer, que permiten a los atacantes escribir código malicioso en áreas de memoria reservadas para el kernel.
+
+Para mitigar el riesgo de vulnerabilidades del kernel, es importante mantener actualizado el sistema operativo y aplicar parches de seguridad tan pronto como estén disponibles.
+
+A continuación, se os comparte el enlace a la máquina Sumo 1 de Vulnhub, la cual estaremos desplegando en esta clase para mostrar un ejemplo práctico de explotación del kernel:
+
+- Máquina Sumo 1: https://www.vulnhub.com/entry/sumo-1,480/
+
+
+## 7.9. Abuso de grupos de usuario especiales
+
+En el contexto de Linux, los grupos se utilizan para organizar a los usuarios y asignar permisos para acceder a los recursos del sistema. Los usuarios pueden pertenecer a uno o varios grupos, y los grupos pueden tener diferentes niveles de permisos para acceder a los recursos del sistema.
+
+Existen grupos especiales en Linux, como ‘lxd‘ o ‘docker‘, que se utilizan para permitir a los usuarios ejecutar contenedores de manera segura y eficiente. Sin embargo, si un usuario malintencionado tiene acceso a uno de estos grupos, podría aprovecharlo para obtener privilegios elevados en el sistema.
+
+Por ejemplo, si un usuario tiene acceso al grupo ‘docker‘, podría utilizar la herramienta Docker para desplegar nuevos contenedores en el sistema. Durante el proceso de despliegue, el usuario podría aprovecharse de las monturas (mounts) para hacer que ciertos recursos inaccesibles en la máquina host estén disponibles en el contenedor. Al ganar acceso al contenedor como usuario ‘root‘, el usuario malintencionado podría inferir o manipular el contenido de estos recursos desde el contenedor.
+
+Para mitigar el riesgo de abuso de grupos de usuario especiales, es importante limitar cuidadosamente el acceso a estos grupos y asegurarse de que sólo se asignan a usuarios confiables que realmente necesitan acceder a ellos.
+
+
+## 7.10. Abuso de servicios internos del sistema
+
+Los servicios internos son componentes esenciales que operan en segundo plano dentro de un sistema operativo, encargándose de funciones críticas como la gestión de red, impresión, actualización de software y monitoreo del sistema, entre otros.
+
+No obstante, si estos servicios no están configurados adecuadamente y se encuentran activos, pueden representar una brecha de seguridad significativa. Los atacantes podrían explotar estos servicios para obtener acceso no autorizado al sistema y llevar a cabo actividades malintencionadas.
+
+Un ejemplo concreto sería un servicio de red mal configurado con permisos elevados. Si un atacante logra identificarlo y hallar una forma de aprovecharlo, podría utilizarlo para escalar privilegios y obtener acceso de administrador.
+
+En esta clase, analizaremos un caso ilustrativo de cómo un atacante podría, en primer lugar, detectar un servicio activo en el sistema y, posteriormente, explotarlo para incrementar sus privilegios de usuario.
+
+
+## 7.11. Abuso de binarios especificos
+
+En esta clase, analizaremos cómo elevar nuestros privilegios de usuario mediante la explotación de dos binarios diferentes como ejemplos ilustrativos.
+
+El primer ejemplo se enfoca en explotar el binario legítimo exim-4.84-7, que presenta una vulnerabilidad identificada como CVE-2016-1531. Esta vulnerabilidad permite a un atacante ejecutar comandos privilegiados mediante el abuso de ciertas variables de entorno. Estudiaremos cómo aprovechar esta vulnerabilidad para escalar privilegios y acceder a funciones restringidas.
+
+El segundo ejemplo aborda un Buffer Overflow en un binario personalizado en una máquina Linux de 32 bits con protecciones activas y ASLR habilitado. En este caso, nos centraremos en explotar un ret2libc en un binario que posee permisos SUID y cuyo propietario es root. A través del buffer overflow, demostraremos cómo inyectar comandos privilegiados y, en consecuencia, elevar los privilegios de usuario.
+
+La idea de esta clase es que sirva para demostrar cómo ciertos binarios, tanto legítimos como personalizados, pueden ser explotados para obtener privilegios elevados, lo que destaca la importancia de una adecuada configuración y protección en los sistemas.
+
+A continuación, se os comparte el enlace de descarga de la máquina Pluck de Vulnhub, la cual estaremos utilizando para representar el primer caso de explotación:
+
+- Máquina Pluck de Vulnhub: https://www.vulnhub.com/entry/pluck-1,178/
+
+Por otro lado, os compartimos el enlace directo de descarga para Ubuntu 16.04.7 LTS (Xenial Xerus):
+
+- Ubuntu 16.04.7: https://releases.ubuntu.com/16.04/
+
+Por último, se os comparte el enlace de descarga al binario el cual estaremos explotando para este segundo caso. Este binario es necesario que lo depositéis en alguna ruta del sistema y que le otorguéis de permisos de ejecución:
+
+- Binario CUSTOM: https://hack4u.io/wp-content/uploads/2023/04/custom *(QUITADLE LA EXTENSIÓN TXT UNA VEZ DESCARGADO)*
+
+
+## 7.12. Secuestro de la biblioteca de objetos compartidos enlazadas dinámicamente
+
+Las bibliotecas compartidas son archivos que contienen funciones y recursos utilizados por múltiples programas. Cuando un programa requiere una función de una biblioteca compartida, el sistema operativo busca la biblioteca y enlaza dinámicamente la función requerida durante la ejecución del programa. Sin embargo, si el sistema no encuentra la biblioteca en las rutas predeterminadas, puede buscarla en otros directorios.
+
+Un atacante puede aprovechar esta situación creando una biblioteca compartida maliciosa con el mismo nombre que la biblioteca legítima y colocándola en un directorio donde el sistema la buscará. Cuando el programa intenta cargar la biblioteca, el sistema cargará la versión maliciosa en lugar de la legítima, permitiendo al atacante ejecutar código malicioso con los privilegios del programa víctima.
+
+En esta clase, analizaremos cómo se lleva a cabo el secuestro de bibliotecas de objetos compartidos enlazados dinámicamente y cómo identificar situaciones en las que esta técnica puede ser aplicada.
+
+A continuación, se os comparte una de las herramientas que utilizamos en esta clase para analizar la ejecución de un programa escrito en C/C++:
+
+- Herramienta Uftrace: https://github.com/namhyung/uftrace
+
+Asimismo, se os comparte el enlace directo a la plataforma AttackDefense, donde estaremos resolviendo un reto que involucra esta misma temática:
+
+- AttackDefense: https://attackdefense.com
+
+
+## 7.13. Docker Breakout
+
+En la clase actual, exploraremos diversas técnicas para abusar de Docker con el objetivo de elevar nuestros privilegios de usuario y escapar del contenedor hacia la máquina host. Examinaremos situaciones específicas y discutiremos las implicaciones de seguridad en cada caso.
+
+Las técnicas que se tratarán en esta clase incluyen:
+
+- Uso de monturas en el despliegue de contenedores para acceder a archivos privilegiados del sistema host. Analizaremos cómo un atacante puede aprovechar las monturas para manipular los archivos del host y comprometer la seguridad del sistema.
+- Despliegue de contenedores con la compartición de procesos (–pid=host) y permisos privilegiados (–privileged). Veremos cómo inyectar un shellcode malicioso en un proceso en ejecución como root, lo que podría permitir al atacante tomar control del sistema.
+- Uso de Portainer para administrar el despliegue de un contenedor. Discutiremos cómo, mediante el empleo de monturas, un atacante podría ingresar y manipular archivos privilegiados del sistema host y escapar del contenedor.
+- Abuso de la API de Docker por el puerto 2375 para la creación de imágenes, despliegue de contenedores e inyección de comandos privilegiados en la máquina host. Examinaremos cómo un atacante puede explotar la API de Docker para comprometer la seguridad del host y lograr la ejecución de comandos con privilegios elevados.
+
+Al finalizar esta clase, comprenderás las vulnerabilidades potenciales asociadas con Docker y aprenderás a identificar los posibles riesgos de seguridad en entornos basados en contenedores.

Introduccion-hacking-hack4u/tema_8_buffer_overflow/README.md

@@ -0,0 +1,132 @@
+# Buffer Overflow
+
+Índice:
+- [Buffer Overflow](#buffer-overflow)
+  - [8.1. Introducción al Buffer Overflow](#81-introducción-al-buffer-overflow)
+  - [8.2. Creación de un laboratiorio de pruebas e instalación de Immunity Debugger](#82-creación-de-un-laboratiorio-de-pruebas-e-instalación-de-immunity-debugger)
+  - [8.3. Fase inicial de Fuzzing y tomando el control de registro EIP](#83-fase-inicial-de-fuzzing-y-tomando-el-control-de-registro-eip)
+  - [8.4. Asignación de espacio depara el Shellcode](#84-asignación-de-espacio-depara-el-shellcode)
+  - [8.5. Generación de Bytearrays y detección de badchars](#85-generación-de-bytearrays-y-detección-de-badchars)
+  - [8.6. Búsqueda de OpCodes para entrar al ESP y cargar nuestro ShellCode](#86-búsqueda-de-opcodes-para-entrar-al-esp-y-cargar-nuestro-shellcode)
+  - [8.7. Uso de NOPs, desplazamientos en pila e interpretación del Shellcode para lograr RCE](#87-uso-de-nops-desplazamientos-en-pila-e-interpretación-del-shellcode-para-lograr-rce)
+  - [8.8. Modificación del Shellcode para controlar el comando que se desea ejecutar](#88-modificación-del-shellcode-para-controlar-el-comando-que-se-desea-ejecutar)
+  - [8.9. Explotando un nuevo binario para reforzar lo aprendido](#89-explotando-un-nuevo-binario-para-reforzar-lo-aprendido)
+  - [8.10. Funcionamiento y creación manual de Shellcodes](#810-funcionamiento-y-creación-manual-de-shellcodes)
+
+
+## 8.1. Introducción al Buffer Overflow
+
+El buffer overflow (desbordamiento de búfer) es una vulnerabilidad común en software que puede permitir a un atacante ejecutar código malicioso o tomar control de un sistema comprometido.
+
+Esta vulnerabilidad se produce cuando un programa intenta almacenar más datos en un búfer (zona de memoria temporal para almacenamiento de datos) de lo que se había previsto, y al exceder la capacidad del búfer, los datos adicionales se escriben en otras zonas de memoria adyacentes.
+
+Esto puede permitir que un atacante escriba código malicioso en estas zonas de memoria y sobrescriba otros datos críticos del sistema, como la dirección de retorno de una función o la dirección de memoria donde se almacena una variable, permitiendo al atacante tomar el control del flujo del programa.
+
+Los impactos de un buffer overflow pueden ser graves, ya que un atacante puede aprovechar esta vulnerabilidad para obtener información confidencial, robar datos o incluso tomar el control completo del sistema. Si los atacantes disponen del conocimiento necesario, pueden incluso conseguir ejecutar comandos maliciosos en el sistema comprometido.
+
+En las siguientes clases, se verán ejemplos concretos de explotación de buffer overflow en sistemas Windows, lo que ayudará a comprender cómo los atacantes pueden aprovechar esta vulnerabilidad y cómo se pueden tomar medidas preventivas para proteger los sistemas y las aplicaciones.
+
+
+## 8.2. Creación de un laboratiorio de pruebas e instalación de Immunity Debugger
+
+En esta clase, estaremos configurando todo el laboratorio para poder practicar nuestros primeros casos de Buffer Overflow.
+
+Para ello, necesitarás instalar las siguientes cosas:
+
+- Windows 7 Home Premium: https://windows-7-home-premium.uptodown.com/windows
+- Immunity Debugger: https://immunityinc.com/products/debugger/
+- mona.py: https://raw.githubusercontent.com/corelan/mona/master/mona.py
+- SLMail: https://slmail.software.informer.com/download/
+
+Asimismo, recordad que es muy importante deshabilitar el DEP (Data Execution Prevention), de lo contrario los Buffer Overflow que estaremos haciendo no funcionarán.
+
+DEP (Data Execution Prevention) es una medida de seguridad que se utiliza para prevenir la ejecución de código malicioso en sistemas comprometidos a través de un buffer overflow.
+
+DEP trabaja marcando ciertas áreas de memoria como “no ejecutables“, lo que significa que cualquier intento de ejecutar código en esas áreas de memoria será bloqueado y se producirá una excepción.
+
+Esto es especialmente útil para prevenir ataques de buffer overflow que intentan aprovecharse de la ejecución de código en zonas de memoria vulnerables. Al marcar estas zonas de memoria como “no ejecutables”, DEP puede prevenir que el código malicioso se ejecute y proteger el sistema de posibles daños. Aún así, esto puede no ser suficiente para impedir que el atacante logre inyectar sus instrucciones maliciosas.
+
+
+## 8.3. Fase inicial de Fuzzing y tomando el control de registro EIP
+
+En la fase inicial de explotación de un buffer overflow, una de las primeras tareas es averiguar los límites del programa objetivo. Esto se hace probando a introducir más caracteres de los debidos en diferentes campos de entrada del programa, como una cadena de texto o un archivo, hasta que se detecte que la aplicación se corrompe o falla.
+
+Una vez que se encuentra el límite del campo de entrada, el siguiente paso es averiguar el offset, que corresponde al número exacto de caracteres que se deben introducir para provocar una corrupción en el programa y, por lo tanto, para sobrescribir el valor del registro EIP.
+
+El registro EIP (Extended Instruction Pointer) es un registro de la CPU que apunta a la dirección de memoria donde se encuentra la siguiente instrucción que se va a ejecutar. En un buffer overflow exitoso, el valor del registro EIP se sobrescribe con una dirección controlada por el atacante, lo que permite ejecutar código malicioso en lugar del código original del programa.
+
+Por lo tanto, el objetivo de averiguar el offset es determinar el número exacto de caracteres que se deben introducir en el campo de entrada para sobrescribir el valor del registro EIP y apuntar a la dirección de memoria controlada por el atacante. Una vez que se conoce el offset, el atacante puede diseñar un exploit personalizado para el programa objetivo que permita tomar control del registro EIP y ejecutar código malicioso.
+
+
+## 8.4. Asignación de espacio depara el Shellcode
+
+Una vez que se ha encontrado el offset y se ha sobrescrito el valor del registro EIP en un buffer overflow, el siguiente paso es identificar en qué parte de la memoria se están representando los caracteres introducidos en el campo de entrada.
+
+Después de sobrescribir el valor del registro EIP, cualquier carácter adicional que introduzcamos en el campo de entrada, veremos desde Immunity Debugger que en este caso particular estos estarán representados al comienzo de la pila (stack) en el registro ESP (Extended Stack Pointer). El ESP (Extended Stack Pointer) es un registro de la CPU que se utiliza para manejar la pila (stack) en un programa. La pila es una zona de memoria temporal que se utiliza para almacenar valores y direcciones de retorno de las funciones a medida que se van llamando en el programa.
+
+Una vez que se ha identificado la ubicación de los caracteres en la memoria, la idea principal en este punto es introducir un shellcode en esa ubicación, que son instrucciones de bajo nivel las cuales en este caso corresponderán a una instrucción maliciosa.
+
+El shellcode se introduce en la pila y se coloca en la misma dirección de memoria donde se colocaron los caracteres sobrescritos. En otras palabras, se aprovecha el desbordamiento del búfer para ejecutar el shellcode malicioso y tomar control del sistema.
+
+Es importante tener en cuenta que el shellcode debe ser diseñado cuidadosamente para evitar que se detecte como un programa malicioso, y debe ser compatible con la arquitectura de la CPU y el sistema operativo que se está atacando.
+
+En resumen, la asignación de espacio para el shellcode implica identificar la ubicación en la memoria donde se colocaron los caracteres sobrescritos en el buffer overflow y colocar allí el shellcode malicioso. Sin embargo, no todos los caracteres del shellcode pueden ser interpretados. En la siguiente clase veremos cómo detectar estos badchars y cómo generar un shellcode que no disponga de estos caracteres.
+
+
+## 8.5. Generación de Bytearrays y detección de badchars
+
+En la generación de nuestro shellcode malicioso para la explotación del buffer overflow, es posible que algunos caracteres no sean interpretados correctamente por el programa objetivo. Estos caracteres se conocen como “badchars” y pueden causar que el shellcode falle o que el programa objetivo se cierre inesperadamente.
+
+Para evitar esto, es importante identificar y eliminar los badchars del shellcode. En esta clase, veremos cómo desde Immunity Debugger podremos aprovechar la funcionalidad Mona para generar diferentes bytearrays con casi todos los caracteres representados, y luego identificar los caracteres que el programa objetivo no logra interpretar.
+
+Una vez identificados los badchars, se pueden descartar del shellcode final y generar un nuevo shellcode que no contenga estos caracteres. Para identificar los badchars, se pueden utilizar diferentes técnicas, como la introducción de diferentes bytearrays con caracteres hexadecimales consecutivos, que permiten identificar los caracteres que el programa objetivo no logra interpretar.
+
+Estos caracteres irán representados en la pila (ESP), que será donde veremos qué caracteres son los que no están siendo representados, identificando así los badchars.
+
+
+## 8.6. Búsqueda de OpCodes para entrar al ESP y cargar nuestro ShellCode
+
+Una vez que se ha generado el shellcode malicioso y se han detectado los badchars, el siguiente paso es hacer que el flujo del programa entre en el shellcode para que sea interpretado. La idea es hacer que el registro EIP apunte a una dirección de memoria donde se aplique un opcode que realice un salto al registro ESP (JMP ESP), que es donde se encuentra el shellcode. Esto es así dado que de primeras no podemos hacer que el EIP apunte directamente a nuestro shellcode.
+
+Para encontrar el opcode JMP ESP, se pueden utilizar diferentes herramientas, como mona.py, que permite buscar opcodes en módulos específicos de la memoria del programa objetivo. Una vez que se ha encontrado el opcode ‘JMP ESP‘, se puede sobrescribir el valor del registro EIP con la dirección de memoria donde se encuentra el opcode, lo que permitirá saltar al registro ESP y ejecutar el shellcode malicioso.
+
+La búsqueda de opcodes para entrar al registro ESP y cargar el shellcode es una técnica utilizada para hacer que el flujo del programa entre en el shellcode para que sea interpretado. Se utiliza el opcode JMP ESP para saltar a la dirección de memoria del registro ESP, donde se encuentra el shellcode.
+
+
+## 8.7. Uso de NOPs, desplazamientos en pila e interpretación del Shellcode para lograr RCE
+
+Una vez que se ha encontrado la dirección del opcode que aplica el salto al registro ESP, es posible que el shellcode no sea interpretado correctamente debido a que su ejecución puede requerir más tiempo del que el procesador tiene disponible antes de continuar con la siguiente instrucción del programa.
+
+Para solucionar este problema, se suelen utilizar técnicas como la introducción de NOPS (instrucciones de no operación) antes del shellcode en la pila. Los NOPS no realizan ninguna operación, pero permiten que el procesador tenga tiempo adicional para interpretar el shellcode antes de continuar con la siguiente instrucción del programa.
+
+Otra técnica que se suele utilizar es el desplazamiento en la pila, que implica modificar el registro ESP para reservar espacio adicional para el shellcode y permitir que se ejecute sin problemas. Por ejemplo, se puede utilizar la instrucción “sub esp, 0x10” para desplazar el registro ESP 16 bytes hacia abajo en la pila y reservar espacio adicional para el shellcode.
+
+Ya con esto, ¡habríamos conseguido vulnerar el sistema a través del Buffer Overflow!
+
+
+## 8.8. Modificación del Shellcode para controlar el comando que se desea ejecutar
+
+Además de los payloads que se han utilizado en las clases anteriores, también es posible utilizar payloads como “windows/exec” para cargar directamente el comando que se desea ejecutar en la variable CMD del payload. Esto permite crear un nuevo shellcode que, una vez interpretado, ejecutará directamente la instrucción deseada.
+
+El payload “windows/exec” es un payload de Metasploit que permite ejecutar un comando arbitrario en la máquina objetivo. Este payload requiere que se especifique el comando a ejecutar a través de la variable CMD en el payload. Al generar el shellcode con msfvenom, se puede utilizar el parámetro “-p windows/exec CMD=<comando>” para especificar el comando que se desea ejecutar.
+
+Una vez generado el shellcode con el comando deseado, se puede utilizar la técnica de buffer overflow para sobrescribir el registro EIP y hacer que el flujo del programa entre en el shellcode. Al interpretar el shellcode, se ejecutará directamente el comando especificado en la variable CMD.
+
+
+## 8.9. Explotando un nuevo binario para reforzar lo aprendido
+
+Con el objetivo de reforzar todo lo aprendido hasta ahora en esta sección, en esta clase vamos a intentar explotar otro Buffer Overflow. El procedimiento que aplicaremos será el mismo, aunque la fase inicial y la forma de entablar las conexiones en Python cambiarán un poco.
+
+A continuación, se os comparte el enlace de descarga al software vulnerable que estaremos ejecutando:
+
+- MiniShare: https://es.osdn.net/projects/sfnet_minishare/downloads/OldFiles/minishare-1.4.1.exe/
+
+
+## 8.10. Funcionamiento y creación manual de Shellcodes
+
+Los shellcodes son programas pequeños y altamente optimizados que se utilizan para explotar vulnerabilidades de seguridad y ejecutar código malicioso en una máquina objetivo. Los shellcodes suelen ser escritos en lenguaje ensamblador para garantizar una ejecución rápida y eficiente.
+
+En esta clase, exploraremos cómo funcionan los shellcodes por detrás mediante la creación de algunos shellcodes manualmente. Por ejemplo, intentaremos crear un shellcode que muestre por consola el mensaje “Hola mundo” utilizando interrupciones del sistema. Asimismo, intentaremos aplicar una llamada a nivel de sistema para lograr ejecutar un comando deseado.
+
+Una vez que se ha generado el compilado resultante, se puede utilizar el comando objdump para convertir el archivo binario generado en un shellcode que pueda ser utilizado en un Buffer Overflow.
+

Introduccion-hacking-hack4u/tema_9_material_adic/README.md

@@ -0,0 +1,21 @@
+# Material adicional
+
+Índice:
+- [Material adicional](#material-adicional)
+  - [9.1. Introducción a Metasploit](#91-introducción-a-metasploit)
+  - [9.2. Introducción a SQLMap](#92-introducción-a-sqlmap)
+  - [9.3. Introducción a Pivoting](#93-introducción-a-pivoting)
+
+
+## 9.1. Introducción a Metasploit
+
+Metasploit es una plataforma de pruebas de penetración (Penetration Testing Framework) que se utiliza para realizar pruebas de seguridad en sistemas y aplicaciones. Esta plataforma es ampliamente utilizada por investigadores de seguridad, pentesters y profesionales de la seguridad para descubrir vulnerabilidades y realizar pruebas de explotación de vulnerabilidades. Metasploit se basa en un conjunto de herramientas de seguridad que incluyen un framework de desarrollo de exploits, un motor de base de datos de vulnerabilidades y una colección de módulos de explotación de vulnerabilidades.
+
+En términos prácticos, Metasploit se utiliza para probar la seguridad de un sistema o aplicación mediante la realización de pruebas de penetración, con el objetivo de identificar y explotar vulnerabilidades de seguridad. Para hacer esto, Metasploit proporciona una gran cantidad de exploits, payloads y módulos de post-explotación, que pueden ser utilizados por los profesionales de seguridad para identificar vulnerabilidades y explotarlas. Al utilizar Metasploit, los profesionales de la seguridad pueden simular ataques reales y descubrir vulnerabilidades en sistemas y aplicaciones antes de que los atacantes malintencionados puedan hacerlo, lo que les permite corregir las vulnerabilidades y mejorar la seguridad de sus sistemas.
+
+
+## 9.2. Introducción a SQLMap
+
+
+## 9.3. Introducción a Pivoting
+