# Privilage escalation Nuestro acceso inicial a un servidor remoto suele ser con un usuario con pocos privilegios, lo que no nos daría acceso completo a través de la máquina. Para obtener acceso completo, necesitaremos encontrar una vulnerabilidad interna/local que escale nuestros privilegios a `root`(usuario en `Linux`) o al usuario `administrator`(usuario en `Windows`) . ## Checklists de escaladas de privilegios: * **Hacktricks:** * **Linux:** * **Windows:** * **PayloadsAllTheThings:** * **Linux:** * **Windows:** ## Scripts de enumeración: * **Linux:** * **LinEnum:** * **linuxprivchecker:** * **Windows:** * **Seatbelt:** * **JAWS:** ## Software vulnerable: Otra cosa que se debe mirar es los softwares instalados. Para ver que softwares están instalados en los sistemas operativos. **Linux:** ```sh dpkg -l ``` **Windows:** ```sh C:\Program Files ``` Una vez tengamos los softwares instalados posemos sacar sus versiones y buscar algún exploit público. ## Privilegios de usuario: Otro aspecto crítico a considerar tras acceder a un servidor son los privilegios disponibles para el usuario al que tenemos acceso. Supongamos que podemos ejecutar comandos específicos como root (o como otro usuario). En ese caso, podríamos escalar nuestros privilegios a root/usuarios del sistema u obtener acceso como otro usuario. A continuación, se presentan algunas formas comunes de explotar ciertos privilegios de usuario: * Sudo * SUID * Privilegios de token en Windows El comando `sudo`en Linux permite a un usuario ejecutar comandos como un usuario diferente. Se usa generalmente para permitir que usuarios con privilegios bajos ejecuten comandos como root sin darles acceso como root. Esto se debe a que ciertos comandos solo se pueden ejecutar `tcpdump`ocomo root o permiten al usuario acceder a ciertos directorios exclusivos para root. Para comprobar los privelegios de sudo de nuestro usuari usaremos el siguiente comando: ``` sudo -l ``` La entrada `NOPASSWD`muestra que el comando `/bin/echo` se puede ejecutar sin contraseña. Esto sería útil si accediéramos al servidor a través de una vulnerabilidad y no tuviéramos la contraseña del usuario. Como se indica `user`, podemos ejecutarlo `sudo`con ese usuario y no como root. Una vez que encontramos una aplicación específica que podemos ejecutar `sudo`, podemos buscar maneras de explotarla para obtener acceso root. [GTFOBins](https://gtfobins.github.io/) contiene una lista de comandos y cómo explotarlos mediante \[ nombre del usuario `sudo`]. Podemos buscar la aplicación `sudo`sobre la que tenemos privilegios y, si existe, podría indicarnos el comando exacto que debemos ejecutar para obtener acceso root con dichos `sudo`privilegios. [LOLBAS](https://lolbas-project.github.io) también contiene una lista de aplicaciones de Windows que podemos aprovechar para realizar ciertas funciones, como descargar archivos o ejecutar comandos en el contexto de un usuario privilegiado. ## Tareas programadas: Tanto en Linux como en Windows, existen métodos para ejecutar scripts a intervalos específicos para realizar una tarea. Algunos ejemplos son ejecutar un análisis antivirus cada hora o un script de copia de seguridad cada 30 minutos. Normalmente, hay dos maneras de aprovechar las tareas programadas (Windows) o los trabajos cron (Linux) para escalar nuestros privilegios: 1. Agregar nuevas tareas programadas/trabajos cron 2. Engañarlos para que ejecuten un software malicioso La forma más sencilla es comprobar si tenemos permiso para añadir nuevas tareas programadas. En Linux, una forma común de mantener las tareas programadas es mediante \[nombre del directorio] `Cron Jobs`. Hay directorios específicos que podemos usar para añadir nuevas tareas cron si tenemos `write`permisos sobre ellos. Estos incluyen: * /etc/crontab * /etc/cron.d * /var/spool/cron/crontabs/root Si podemos escribir en un directorio llamado por un trabajo cron, podemos escribir un script bash con un comando de shell inverso, que debería enviarnos un shell inverso cuando se ejecute. ## Credenciales expuestas: A continuación, podemos buscar archivos que podamos leer y comprobar si contienen credenciales expuestas. Esto es muy común con archivos de `configuration`, archivos de `log` y archivos de historial de usuario ( `bash_history`en Linux y `PSReadLine`en Windows). Los scripts de enumeración que comentamos al principio suelen buscar posibles contraseñas en los archivos y proporcionárnoslas. ## Claves SSH: Finalmente, analicemos las claves SSH. Si tenemos acceso de lectura al `.ssh`directorio para un usuario específico, podemos leer sus claves SSH privadas, que se encuentran en \[nombre del directorio `/home/user/.ssh/id_rsa`] o \[nombre del archivo `/root/.ssh/id_rsa`], y usarlas para iniciar sesión en el servidor. Si podemos leer el `/root/.ssh/`directorio y el archivo `id_rsa`, podemos copiarlo a nuestra máquina y usar la flag `-i` para iniciar sesión con él. ```sh nano id_rsa ``` ```sh chmod +600 id_rsa ``` ```sh ssh @ -i id_rsa ``` Si tenemos acceso de escritura al `/.ssh/`directorio de un usuario, podemos colocar nuestra clave pública en el directorio ssh del usuario en \[nombre del usuario] `/home/user/.ssh/authorized_keys`. Esta técnica se suele usar para obtener acceso ssh después de obtener un shell como ese usuario. La configuración actual de SSH no acepta claves escritas por otros usuarios, por lo que solo funcionará si ya tenemos control sobre ese usuario. Primero debemos crear una nueva clave con \[nombre del usuario] `ssh-keygen`y la `-f`bandera para especificar el archivo de salida. ```sh ssh-keygen -f key ``` Esto nos dará dos archivos: `key`(que usaremos con `ssh -i`) y `key.pub`, que copiaremos a la máquina remota. Copiamos `key.pub`, y luego, en la máquina remota, lo añadiremos a `/root/.ssh/authorized_keys`. ```sh echo "ssh-rsa AAAAB...SNIP...M= user@parrot" >> /root/.ssh/authorized_keys ``` ```sh ssh @ -i key ```