247 lines
26 KiB
Markdown
247 lines
26 KiB
Markdown
|
# 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.
|